pulumi-nomad 2.5.0a1744783739__py3-none-any.whl → 2.6.0a1745042960__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- pulumi_nomad/__init__.py +19 -0
- pulumi_nomad/_inputs.py +678 -1
- pulumi_nomad/acl_policy.py +14 -7
- pulumi_nomad/config/__init__.pyi +0 -10
- pulumi_nomad/config/vars.py +0 -14
- pulumi_nomad/csi_volume.py +28 -0
- pulumi_nomad/dynamic_host_volume.py +1005 -0
- pulumi_nomad/dynamic_host_volume_registration.py +740 -0
- pulumi_nomad/get_dynamic_host_volume.py +353 -0
- pulumi_nomad/get_volumes.py +2 -2
- pulumi_nomad/job.py +3 -113
- pulumi_nomad/outputs.py +579 -1
- pulumi_nomad/provider.py +1 -59
- pulumi_nomad/pulumi-plugin.json +1 -1
- {pulumi_nomad-2.5.0a1744783739.dist-info → pulumi_nomad-2.6.0a1745042960.dist-info}/METADATA +1 -1
- {pulumi_nomad-2.5.0a1744783739.dist-info → pulumi_nomad-2.6.0a1745042960.dist-info}/RECORD +18 -15
- {pulumi_nomad-2.5.0a1744783739.dist-info → pulumi_nomad-2.6.0a1745042960.dist-info}/WHEEL +0 -0
- {pulumi_nomad-2.5.0a1744783739.dist-info → pulumi_nomad-2.6.0a1745042960.dist-info}/top_level.txt +0 -0
|
@@ -0,0 +1,1005 @@
|
|
|
1
|
+
# coding=utf-8
|
|
2
|
+
# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
|
|
3
|
+
# *** Do not edit by hand unless you're certain you know what you are doing! ***
|
|
4
|
+
|
|
5
|
+
import builtins
|
|
6
|
+
import copy
|
|
7
|
+
import warnings
|
|
8
|
+
import sys
|
|
9
|
+
import pulumi
|
|
10
|
+
import pulumi.runtime
|
|
11
|
+
from typing import Any, Mapping, Optional, Sequence, Union, overload
|
|
12
|
+
if sys.version_info >= (3, 11):
|
|
13
|
+
from typing import NotRequired, TypedDict, TypeAlias
|
|
14
|
+
else:
|
|
15
|
+
from typing_extensions import NotRequired, TypedDict, TypeAlias
|
|
16
|
+
from . import _utilities
|
|
17
|
+
from . import outputs
|
|
18
|
+
from ._inputs import *
|
|
19
|
+
|
|
20
|
+
__all__ = ['DynamicHostVolumeArgs', 'DynamicHostVolume']
|
|
21
|
+
|
|
22
|
+
@pulumi.input_type
|
|
23
|
+
class DynamicHostVolumeArgs:
|
|
24
|
+
def __init__(__self__, *,
|
|
25
|
+
capabilities: pulumi.Input[Sequence[pulumi.Input['DynamicHostVolumeCapabilityArgs']]],
|
|
26
|
+
plugin_id: pulumi.Input[builtins.str],
|
|
27
|
+
capacity_max: Optional[pulumi.Input[builtins.str]] = None,
|
|
28
|
+
capacity_min: Optional[pulumi.Input[builtins.str]] = None,
|
|
29
|
+
constraints: Optional[pulumi.Input[Sequence[pulumi.Input['DynamicHostVolumeConstraintArgs']]]] = None,
|
|
30
|
+
name: Optional[pulumi.Input[builtins.str]] = None,
|
|
31
|
+
namespace: Optional[pulumi.Input[builtins.str]] = None,
|
|
32
|
+
node_id: Optional[pulumi.Input[builtins.str]] = None,
|
|
33
|
+
node_pool: Optional[pulumi.Input[builtins.str]] = None,
|
|
34
|
+
parameters: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None):
|
|
35
|
+
"""
|
|
36
|
+
The set of arguments for constructing a DynamicHostVolume resource.
|
|
37
|
+
:param pulumi.Input[Sequence[pulumi.Input['DynamicHostVolumeCapabilityArgs']]] capabilities: `(block: <optional>)` - Option for validating the capability of a
|
|
38
|
+
volume. Each capability block has the following attributes:
|
|
39
|
+
:param pulumi.Input[builtins.str] plugin_id: Plugin ID
|
|
40
|
+
:param pulumi.Input[builtins.str] capacity_max: `(string: <optional>)` - Option for requesting a maximum
|
|
41
|
+
capacity, in bytes. The capacity of a volume may be the physical size of a
|
|
42
|
+
disk, or a quota, depending on the plugin. The specific size of the resulting
|
|
43
|
+
volume is somewhere between `capacity_min` and `capacity_max`; the exact
|
|
44
|
+
behavior is up to the plugin. If you want to specify an exact size, set
|
|
45
|
+
`capacity_min` and `capacity_max` to the same value. Accepts human-friendly
|
|
46
|
+
suffixes such as `"100GiB"`. Plugins that cannot restrict the size of volumes
|
|
47
|
+
may ignore this field.
|
|
48
|
+
:param pulumi.Input[builtins.str] capacity_min: `(string: <optional>)` - Option for requesting a minimum
|
|
49
|
+
capacity, in bytes. The capacity of a volume may be the physical size of a
|
|
50
|
+
disk, or a quota, depending on the plugin. The specific size of the resulting
|
|
51
|
+
volume is somewhere between `capacity_min` and `capacity_max`; the exact
|
|
52
|
+
behavior is up to the plugin. If you want to specify an exact size, set
|
|
53
|
+
`capacity_min` and `capacity_max` to the same value. Accepts human-friendly
|
|
54
|
+
suffixes such as `"100GiB"`. Plugins that cannot restrict the size of volumes
|
|
55
|
+
may ignore this field.
|
|
56
|
+
:param pulumi.Input[Sequence[pulumi.Input['DynamicHostVolumeConstraintArgs']]] constraints: `(block: <optional>)` - A restriction on the eligible nodes where
|
|
57
|
+
a volume can be created, similar to the [`constraint`][] block on a Nomad job
|
|
58
|
+
specification.. You can provide multiple `constraint` blocks to add more
|
|
59
|
+
constraints. Each constraint block has the following attributes.
|
|
60
|
+
:param pulumi.Input[builtins.str] name: `(string: <required>)` - The name of the volume, which is used as the
|
|
61
|
+
[`volume.source`][volume_source] field in job specifications that claim this
|
|
62
|
+
volume. Host volume names must be unique per node. Names are visible to any
|
|
63
|
+
user with `node:read` ACL, even across namespaces, so they should not be
|
|
64
|
+
treated as sensitive values.
|
|
65
|
+
:param pulumi.Input[builtins.str] namespace: `(string: <optional>)` - The namespace of the volume. This field
|
|
66
|
+
overrides the namespace provided by the `-namespace` flag or `NOMAD_NAMESPACE`
|
|
67
|
+
environment variable. Defaults to `"default"` if unset.
|
|
68
|
+
:param pulumi.Input[builtins.str] node_id: `(string: <optional>)` - A specific node where you would like the
|
|
69
|
+
volume to be created.
|
|
70
|
+
:param pulumi.Input[builtins.str] node_pool: `(string: <optional>)` - A specific node pool where you would like
|
|
71
|
+
the volume to be created. If you also provide `node_id`, the node must be in the
|
|
72
|
+
provided `node_pool`.
|
|
73
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] parameters: `(map<string|string>: <optional>)` - A key-value map of strings
|
|
74
|
+
passed directly to the plugin to configure the volume. The details of these
|
|
75
|
+
parameters are specific to the plugin.
|
|
76
|
+
"""
|
|
77
|
+
pulumi.set(__self__, "capabilities", capabilities)
|
|
78
|
+
pulumi.set(__self__, "plugin_id", plugin_id)
|
|
79
|
+
if capacity_max is not None:
|
|
80
|
+
pulumi.set(__self__, "capacity_max", capacity_max)
|
|
81
|
+
if capacity_min is not None:
|
|
82
|
+
pulumi.set(__self__, "capacity_min", capacity_min)
|
|
83
|
+
if constraints is not None:
|
|
84
|
+
pulumi.set(__self__, "constraints", constraints)
|
|
85
|
+
if name is not None:
|
|
86
|
+
pulumi.set(__self__, "name", name)
|
|
87
|
+
if namespace is not None:
|
|
88
|
+
pulumi.set(__self__, "namespace", namespace)
|
|
89
|
+
if node_id is not None:
|
|
90
|
+
pulumi.set(__self__, "node_id", node_id)
|
|
91
|
+
if node_pool is not None:
|
|
92
|
+
pulumi.set(__self__, "node_pool", node_pool)
|
|
93
|
+
if parameters is not None:
|
|
94
|
+
pulumi.set(__self__, "parameters", parameters)
|
|
95
|
+
|
|
96
|
+
@property
|
|
97
|
+
@pulumi.getter
|
|
98
|
+
def capabilities(self) -> pulumi.Input[Sequence[pulumi.Input['DynamicHostVolumeCapabilityArgs']]]:
|
|
99
|
+
"""
|
|
100
|
+
`(block: <optional>)` - Option for validating the capability of a
|
|
101
|
+
volume. Each capability block has the following attributes:
|
|
102
|
+
"""
|
|
103
|
+
return pulumi.get(self, "capabilities")
|
|
104
|
+
|
|
105
|
+
@capabilities.setter
|
|
106
|
+
def capabilities(self, value: pulumi.Input[Sequence[pulumi.Input['DynamicHostVolumeCapabilityArgs']]]):
|
|
107
|
+
pulumi.set(self, "capabilities", value)
|
|
108
|
+
|
|
109
|
+
@property
|
|
110
|
+
@pulumi.getter(name="pluginId")
|
|
111
|
+
def plugin_id(self) -> pulumi.Input[builtins.str]:
|
|
112
|
+
"""
|
|
113
|
+
Plugin ID
|
|
114
|
+
"""
|
|
115
|
+
return pulumi.get(self, "plugin_id")
|
|
116
|
+
|
|
117
|
+
@plugin_id.setter
|
|
118
|
+
def plugin_id(self, value: pulumi.Input[builtins.str]):
|
|
119
|
+
pulumi.set(self, "plugin_id", value)
|
|
120
|
+
|
|
121
|
+
@property
|
|
122
|
+
@pulumi.getter(name="capacityMax")
|
|
123
|
+
def capacity_max(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
124
|
+
"""
|
|
125
|
+
`(string: <optional>)` - Option for requesting a maximum
|
|
126
|
+
capacity, in bytes. The capacity of a volume may be the physical size of a
|
|
127
|
+
disk, or a quota, depending on the plugin. The specific size of the resulting
|
|
128
|
+
volume is somewhere between `capacity_min` and `capacity_max`; the exact
|
|
129
|
+
behavior is up to the plugin. If you want to specify an exact size, set
|
|
130
|
+
`capacity_min` and `capacity_max` to the same value. Accepts human-friendly
|
|
131
|
+
suffixes such as `"100GiB"`. Plugins that cannot restrict the size of volumes
|
|
132
|
+
may ignore this field.
|
|
133
|
+
"""
|
|
134
|
+
return pulumi.get(self, "capacity_max")
|
|
135
|
+
|
|
136
|
+
@capacity_max.setter
|
|
137
|
+
def capacity_max(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
138
|
+
pulumi.set(self, "capacity_max", value)
|
|
139
|
+
|
|
140
|
+
@property
|
|
141
|
+
@pulumi.getter(name="capacityMin")
|
|
142
|
+
def capacity_min(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
143
|
+
"""
|
|
144
|
+
`(string: <optional>)` - Option for requesting a minimum
|
|
145
|
+
capacity, in bytes. The capacity of a volume may be the physical size of a
|
|
146
|
+
disk, or a quota, depending on the plugin. The specific size of the resulting
|
|
147
|
+
volume is somewhere between `capacity_min` and `capacity_max`; the exact
|
|
148
|
+
behavior is up to the plugin. If you want to specify an exact size, set
|
|
149
|
+
`capacity_min` and `capacity_max` to the same value. Accepts human-friendly
|
|
150
|
+
suffixes such as `"100GiB"`. Plugins that cannot restrict the size of volumes
|
|
151
|
+
may ignore this field.
|
|
152
|
+
"""
|
|
153
|
+
return pulumi.get(self, "capacity_min")
|
|
154
|
+
|
|
155
|
+
@capacity_min.setter
|
|
156
|
+
def capacity_min(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
157
|
+
pulumi.set(self, "capacity_min", value)
|
|
158
|
+
|
|
159
|
+
@property
|
|
160
|
+
@pulumi.getter
|
|
161
|
+
def constraints(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DynamicHostVolumeConstraintArgs']]]]:
|
|
162
|
+
"""
|
|
163
|
+
`(block: <optional>)` - A restriction on the eligible nodes where
|
|
164
|
+
a volume can be created, similar to the [`constraint`][] block on a Nomad job
|
|
165
|
+
specification.. You can provide multiple `constraint` blocks to add more
|
|
166
|
+
constraints. Each constraint block has the following attributes.
|
|
167
|
+
"""
|
|
168
|
+
return pulumi.get(self, "constraints")
|
|
169
|
+
|
|
170
|
+
@constraints.setter
|
|
171
|
+
def constraints(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DynamicHostVolumeConstraintArgs']]]]):
|
|
172
|
+
pulumi.set(self, "constraints", value)
|
|
173
|
+
|
|
174
|
+
@property
|
|
175
|
+
@pulumi.getter
|
|
176
|
+
def name(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
177
|
+
"""
|
|
178
|
+
`(string: <required>)` - The name of the volume, which is used as the
|
|
179
|
+
[`volume.source`][volume_source] field in job specifications that claim this
|
|
180
|
+
volume. Host volume names must be unique per node. Names are visible to any
|
|
181
|
+
user with `node:read` ACL, even across namespaces, so they should not be
|
|
182
|
+
treated as sensitive values.
|
|
183
|
+
"""
|
|
184
|
+
return pulumi.get(self, "name")
|
|
185
|
+
|
|
186
|
+
@name.setter
|
|
187
|
+
def name(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
188
|
+
pulumi.set(self, "name", value)
|
|
189
|
+
|
|
190
|
+
@property
|
|
191
|
+
@pulumi.getter
|
|
192
|
+
def namespace(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
193
|
+
"""
|
|
194
|
+
`(string: <optional>)` - The namespace of the volume. This field
|
|
195
|
+
overrides the namespace provided by the `-namespace` flag or `NOMAD_NAMESPACE`
|
|
196
|
+
environment variable. Defaults to `"default"` if unset.
|
|
197
|
+
"""
|
|
198
|
+
return pulumi.get(self, "namespace")
|
|
199
|
+
|
|
200
|
+
@namespace.setter
|
|
201
|
+
def namespace(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
202
|
+
pulumi.set(self, "namespace", value)
|
|
203
|
+
|
|
204
|
+
@property
|
|
205
|
+
@pulumi.getter(name="nodeId")
|
|
206
|
+
def node_id(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
207
|
+
"""
|
|
208
|
+
`(string: <optional>)` - A specific node where you would like the
|
|
209
|
+
volume to be created.
|
|
210
|
+
"""
|
|
211
|
+
return pulumi.get(self, "node_id")
|
|
212
|
+
|
|
213
|
+
@node_id.setter
|
|
214
|
+
def node_id(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
215
|
+
pulumi.set(self, "node_id", value)
|
|
216
|
+
|
|
217
|
+
@property
|
|
218
|
+
@pulumi.getter(name="nodePool")
|
|
219
|
+
def node_pool(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
220
|
+
"""
|
|
221
|
+
`(string: <optional>)` - A specific node pool where you would like
|
|
222
|
+
the volume to be created. If you also provide `node_id`, the node must be in the
|
|
223
|
+
provided `node_pool`.
|
|
224
|
+
"""
|
|
225
|
+
return pulumi.get(self, "node_pool")
|
|
226
|
+
|
|
227
|
+
@node_pool.setter
|
|
228
|
+
def node_pool(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
229
|
+
pulumi.set(self, "node_pool", value)
|
|
230
|
+
|
|
231
|
+
@property
|
|
232
|
+
@pulumi.getter
|
|
233
|
+
def parameters(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]:
|
|
234
|
+
"""
|
|
235
|
+
`(map<string|string>: <optional>)` - A key-value map of strings
|
|
236
|
+
passed directly to the plugin to configure the volume. The details of these
|
|
237
|
+
parameters are specific to the plugin.
|
|
238
|
+
"""
|
|
239
|
+
return pulumi.get(self, "parameters")
|
|
240
|
+
|
|
241
|
+
@parameters.setter
|
|
242
|
+
def parameters(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]):
|
|
243
|
+
pulumi.set(self, "parameters", value)
|
|
244
|
+
|
|
245
|
+
|
|
246
|
+
@pulumi.input_type
|
|
247
|
+
class _DynamicHostVolumeState:
|
|
248
|
+
def __init__(__self__, *,
|
|
249
|
+
capabilities: Optional[pulumi.Input[Sequence[pulumi.Input['DynamicHostVolumeCapabilityArgs']]]] = None,
|
|
250
|
+
capacity: Optional[pulumi.Input[builtins.str]] = None,
|
|
251
|
+
capacity_bytes: Optional[pulumi.Input[builtins.int]] = None,
|
|
252
|
+
capacity_max: Optional[pulumi.Input[builtins.str]] = None,
|
|
253
|
+
capacity_max_bytes: Optional[pulumi.Input[builtins.int]] = None,
|
|
254
|
+
capacity_min: Optional[pulumi.Input[builtins.str]] = None,
|
|
255
|
+
capacity_min_bytes: Optional[pulumi.Input[builtins.int]] = None,
|
|
256
|
+
constraints: Optional[pulumi.Input[Sequence[pulumi.Input['DynamicHostVolumeConstraintArgs']]]] = None,
|
|
257
|
+
host_path: Optional[pulumi.Input[builtins.str]] = None,
|
|
258
|
+
name: Optional[pulumi.Input[builtins.str]] = None,
|
|
259
|
+
namespace: Optional[pulumi.Input[builtins.str]] = None,
|
|
260
|
+
node_id: Optional[pulumi.Input[builtins.str]] = None,
|
|
261
|
+
node_pool: Optional[pulumi.Input[builtins.str]] = None,
|
|
262
|
+
parameters: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None,
|
|
263
|
+
plugin_id: Optional[pulumi.Input[builtins.str]] = None,
|
|
264
|
+
state: Optional[pulumi.Input[builtins.str]] = None):
|
|
265
|
+
"""
|
|
266
|
+
Input properties used for looking up and filtering DynamicHostVolume resources.
|
|
267
|
+
:param pulumi.Input[Sequence[pulumi.Input['DynamicHostVolumeCapabilityArgs']]] capabilities: `(block: <optional>)` - Option for validating the capability of a
|
|
268
|
+
volume. Each capability block has the following attributes:
|
|
269
|
+
:param pulumi.Input[builtins.str] capacity: Provisioned capacity
|
|
270
|
+
:param pulumi.Input[builtins.str] capacity_max: `(string: <optional>)` - Option for requesting a maximum
|
|
271
|
+
capacity, in bytes. The capacity of a volume may be the physical size of a
|
|
272
|
+
disk, or a quota, depending on the plugin. The specific size of the resulting
|
|
273
|
+
volume is somewhere between `capacity_min` and `capacity_max`; the exact
|
|
274
|
+
behavior is up to the plugin. If you want to specify an exact size, set
|
|
275
|
+
`capacity_min` and `capacity_max` to the same value. Accepts human-friendly
|
|
276
|
+
suffixes such as `"100GiB"`. Plugins that cannot restrict the size of volumes
|
|
277
|
+
may ignore this field.
|
|
278
|
+
:param pulumi.Input[builtins.str] capacity_min: `(string: <optional>)` - Option for requesting a minimum
|
|
279
|
+
capacity, in bytes. The capacity of a volume may be the physical size of a
|
|
280
|
+
disk, or a quota, depending on the plugin. The specific size of the resulting
|
|
281
|
+
volume is somewhere between `capacity_min` and `capacity_max`; the exact
|
|
282
|
+
behavior is up to the plugin. If you want to specify an exact size, set
|
|
283
|
+
`capacity_min` and `capacity_max` to the same value. Accepts human-friendly
|
|
284
|
+
suffixes such as `"100GiB"`. Plugins that cannot restrict the size of volumes
|
|
285
|
+
may ignore this field.
|
|
286
|
+
:param pulumi.Input[Sequence[pulumi.Input['DynamicHostVolumeConstraintArgs']]] constraints: `(block: <optional>)` - A restriction on the eligible nodes where
|
|
287
|
+
a volume can be created, similar to the [`constraint`][] block on a Nomad job
|
|
288
|
+
specification.. You can provide multiple `constraint` blocks to add more
|
|
289
|
+
constraints. Each constraint block has the following attributes.
|
|
290
|
+
:param pulumi.Input[builtins.str] host_path: Host path
|
|
291
|
+
:param pulumi.Input[builtins.str] name: `(string: <required>)` - The name of the volume, which is used as the
|
|
292
|
+
[`volume.source`][volume_source] field in job specifications that claim this
|
|
293
|
+
volume. Host volume names must be unique per node. Names are visible to any
|
|
294
|
+
user with `node:read` ACL, even across namespaces, so they should not be
|
|
295
|
+
treated as sensitive values.
|
|
296
|
+
:param pulumi.Input[builtins.str] namespace: `(string: <optional>)` - The namespace of the volume. This field
|
|
297
|
+
overrides the namespace provided by the `-namespace` flag or `NOMAD_NAMESPACE`
|
|
298
|
+
environment variable. Defaults to `"default"` if unset.
|
|
299
|
+
:param pulumi.Input[builtins.str] node_id: `(string: <optional>)` - A specific node where you would like the
|
|
300
|
+
volume to be created.
|
|
301
|
+
:param pulumi.Input[builtins.str] node_pool: `(string: <optional>)` - A specific node pool where you would like
|
|
302
|
+
the volume to be created. If you also provide `node_id`, the node must be in the
|
|
303
|
+
provided `node_pool`.
|
|
304
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] parameters: `(map<string|string>: <optional>)` - A key-value map of strings
|
|
305
|
+
passed directly to the plugin to configure the volume. The details of these
|
|
306
|
+
parameters are specific to the plugin.
|
|
307
|
+
:param pulumi.Input[builtins.str] plugin_id: Plugin ID
|
|
308
|
+
:param pulumi.Input[builtins.str] state: State
|
|
309
|
+
"""
|
|
310
|
+
if capabilities is not None:
|
|
311
|
+
pulumi.set(__self__, "capabilities", capabilities)
|
|
312
|
+
if capacity is not None:
|
|
313
|
+
pulumi.set(__self__, "capacity", capacity)
|
|
314
|
+
if capacity_bytes is not None:
|
|
315
|
+
pulumi.set(__self__, "capacity_bytes", capacity_bytes)
|
|
316
|
+
if capacity_max is not None:
|
|
317
|
+
pulumi.set(__self__, "capacity_max", capacity_max)
|
|
318
|
+
if capacity_max_bytes is not None:
|
|
319
|
+
pulumi.set(__self__, "capacity_max_bytes", capacity_max_bytes)
|
|
320
|
+
if capacity_min is not None:
|
|
321
|
+
pulumi.set(__self__, "capacity_min", capacity_min)
|
|
322
|
+
if capacity_min_bytes is not None:
|
|
323
|
+
pulumi.set(__self__, "capacity_min_bytes", capacity_min_bytes)
|
|
324
|
+
if constraints is not None:
|
|
325
|
+
pulumi.set(__self__, "constraints", constraints)
|
|
326
|
+
if host_path is not None:
|
|
327
|
+
pulumi.set(__self__, "host_path", host_path)
|
|
328
|
+
if name is not None:
|
|
329
|
+
pulumi.set(__self__, "name", name)
|
|
330
|
+
if namespace is not None:
|
|
331
|
+
pulumi.set(__self__, "namespace", namespace)
|
|
332
|
+
if node_id is not None:
|
|
333
|
+
pulumi.set(__self__, "node_id", node_id)
|
|
334
|
+
if node_pool is not None:
|
|
335
|
+
pulumi.set(__self__, "node_pool", node_pool)
|
|
336
|
+
if parameters is not None:
|
|
337
|
+
pulumi.set(__self__, "parameters", parameters)
|
|
338
|
+
if plugin_id is not None:
|
|
339
|
+
pulumi.set(__self__, "plugin_id", plugin_id)
|
|
340
|
+
if state is not None:
|
|
341
|
+
pulumi.set(__self__, "state", state)
|
|
342
|
+
|
|
343
|
+
@property
|
|
344
|
+
@pulumi.getter
|
|
345
|
+
def capabilities(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DynamicHostVolumeCapabilityArgs']]]]:
|
|
346
|
+
"""
|
|
347
|
+
`(block: <optional>)` - Option for validating the capability of a
|
|
348
|
+
volume. Each capability block has the following attributes:
|
|
349
|
+
"""
|
|
350
|
+
return pulumi.get(self, "capabilities")
|
|
351
|
+
|
|
352
|
+
@capabilities.setter
|
|
353
|
+
def capabilities(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DynamicHostVolumeCapabilityArgs']]]]):
|
|
354
|
+
pulumi.set(self, "capabilities", value)
|
|
355
|
+
|
|
356
|
+
@property
|
|
357
|
+
@pulumi.getter
|
|
358
|
+
def capacity(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
359
|
+
"""
|
|
360
|
+
Provisioned capacity
|
|
361
|
+
"""
|
|
362
|
+
return pulumi.get(self, "capacity")
|
|
363
|
+
|
|
364
|
+
@capacity.setter
|
|
365
|
+
def capacity(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
366
|
+
pulumi.set(self, "capacity", value)
|
|
367
|
+
|
|
368
|
+
@property
|
|
369
|
+
@pulumi.getter(name="capacityBytes")
|
|
370
|
+
def capacity_bytes(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
371
|
+
return pulumi.get(self, "capacity_bytes")
|
|
372
|
+
|
|
373
|
+
@capacity_bytes.setter
|
|
374
|
+
def capacity_bytes(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
375
|
+
pulumi.set(self, "capacity_bytes", value)
|
|
376
|
+
|
|
377
|
+
@property
|
|
378
|
+
@pulumi.getter(name="capacityMax")
|
|
379
|
+
def capacity_max(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
380
|
+
"""
|
|
381
|
+
`(string: <optional>)` - Option for requesting a maximum
|
|
382
|
+
capacity, in bytes. The capacity of a volume may be the physical size of a
|
|
383
|
+
disk, or a quota, depending on the plugin. The specific size of the resulting
|
|
384
|
+
volume is somewhere between `capacity_min` and `capacity_max`; the exact
|
|
385
|
+
behavior is up to the plugin. If you want to specify an exact size, set
|
|
386
|
+
`capacity_min` and `capacity_max` to the same value. Accepts human-friendly
|
|
387
|
+
suffixes such as `"100GiB"`. Plugins that cannot restrict the size of volumes
|
|
388
|
+
may ignore this field.
|
|
389
|
+
"""
|
|
390
|
+
return pulumi.get(self, "capacity_max")
|
|
391
|
+
|
|
392
|
+
@capacity_max.setter
|
|
393
|
+
def capacity_max(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
394
|
+
pulumi.set(self, "capacity_max", value)
|
|
395
|
+
|
|
396
|
+
@property
|
|
397
|
+
@pulumi.getter(name="capacityMaxBytes")
|
|
398
|
+
def capacity_max_bytes(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
399
|
+
return pulumi.get(self, "capacity_max_bytes")
|
|
400
|
+
|
|
401
|
+
@capacity_max_bytes.setter
|
|
402
|
+
def capacity_max_bytes(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
403
|
+
pulumi.set(self, "capacity_max_bytes", value)
|
|
404
|
+
|
|
405
|
+
@property
|
|
406
|
+
@pulumi.getter(name="capacityMin")
|
|
407
|
+
def capacity_min(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
408
|
+
"""
|
|
409
|
+
`(string: <optional>)` - Option for requesting a minimum
|
|
410
|
+
capacity, in bytes. The capacity of a volume may be the physical size of a
|
|
411
|
+
disk, or a quota, depending on the plugin. The specific size of the resulting
|
|
412
|
+
volume is somewhere between `capacity_min` and `capacity_max`; the exact
|
|
413
|
+
behavior is up to the plugin. If you want to specify an exact size, set
|
|
414
|
+
`capacity_min` and `capacity_max` to the same value. Accepts human-friendly
|
|
415
|
+
suffixes such as `"100GiB"`. Plugins that cannot restrict the size of volumes
|
|
416
|
+
may ignore this field.
|
|
417
|
+
"""
|
|
418
|
+
return pulumi.get(self, "capacity_min")
|
|
419
|
+
|
|
420
|
+
@capacity_min.setter
|
|
421
|
+
def capacity_min(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
422
|
+
pulumi.set(self, "capacity_min", value)
|
|
423
|
+
|
|
424
|
+
@property
|
|
425
|
+
@pulumi.getter(name="capacityMinBytes")
|
|
426
|
+
def capacity_min_bytes(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
427
|
+
return pulumi.get(self, "capacity_min_bytes")
|
|
428
|
+
|
|
429
|
+
@capacity_min_bytes.setter
|
|
430
|
+
def capacity_min_bytes(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
431
|
+
pulumi.set(self, "capacity_min_bytes", value)
|
|
432
|
+
|
|
433
|
+
@property
|
|
434
|
+
@pulumi.getter
|
|
435
|
+
def constraints(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DynamicHostVolumeConstraintArgs']]]]:
|
|
436
|
+
"""
|
|
437
|
+
`(block: <optional>)` - A restriction on the eligible nodes where
|
|
438
|
+
a volume can be created, similar to the [`constraint`][] block on a Nomad job
|
|
439
|
+
specification.. You can provide multiple `constraint` blocks to add more
|
|
440
|
+
constraints. Each constraint block has the following attributes.
|
|
441
|
+
"""
|
|
442
|
+
return pulumi.get(self, "constraints")
|
|
443
|
+
|
|
444
|
+
@constraints.setter
|
|
445
|
+
def constraints(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DynamicHostVolumeConstraintArgs']]]]):
|
|
446
|
+
pulumi.set(self, "constraints", value)
|
|
447
|
+
|
|
448
|
+
@property
|
|
449
|
+
@pulumi.getter(name="hostPath")
|
|
450
|
+
def host_path(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
451
|
+
"""
|
|
452
|
+
Host path
|
|
453
|
+
"""
|
|
454
|
+
return pulumi.get(self, "host_path")
|
|
455
|
+
|
|
456
|
+
@host_path.setter
|
|
457
|
+
def host_path(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
458
|
+
pulumi.set(self, "host_path", value)
|
|
459
|
+
|
|
460
|
+
@property
|
|
461
|
+
@pulumi.getter
|
|
462
|
+
def name(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
463
|
+
"""
|
|
464
|
+
`(string: <required>)` - The name of the volume, which is used as the
|
|
465
|
+
[`volume.source`][volume_source] field in job specifications that claim this
|
|
466
|
+
volume. Host volume names must be unique per node. Names are visible to any
|
|
467
|
+
user with `node:read` ACL, even across namespaces, so they should not be
|
|
468
|
+
treated as sensitive values.
|
|
469
|
+
"""
|
|
470
|
+
return pulumi.get(self, "name")
|
|
471
|
+
|
|
472
|
+
@name.setter
|
|
473
|
+
def name(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
474
|
+
pulumi.set(self, "name", value)
|
|
475
|
+
|
|
476
|
+
@property
|
|
477
|
+
@pulumi.getter
|
|
478
|
+
def namespace(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
479
|
+
"""
|
|
480
|
+
`(string: <optional>)` - The namespace of the volume. This field
|
|
481
|
+
overrides the namespace provided by the `-namespace` flag or `NOMAD_NAMESPACE`
|
|
482
|
+
environment variable. Defaults to `"default"` if unset.
|
|
483
|
+
"""
|
|
484
|
+
return pulumi.get(self, "namespace")
|
|
485
|
+
|
|
486
|
+
@namespace.setter
|
|
487
|
+
def namespace(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
488
|
+
pulumi.set(self, "namespace", value)
|
|
489
|
+
|
|
490
|
+
@property
|
|
491
|
+
@pulumi.getter(name="nodeId")
|
|
492
|
+
def node_id(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
493
|
+
"""
|
|
494
|
+
`(string: <optional>)` - A specific node where you would like the
|
|
495
|
+
volume to be created.
|
|
496
|
+
"""
|
|
497
|
+
return pulumi.get(self, "node_id")
|
|
498
|
+
|
|
499
|
+
@node_id.setter
|
|
500
|
+
def node_id(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
501
|
+
pulumi.set(self, "node_id", value)
|
|
502
|
+
|
|
503
|
+
@property
|
|
504
|
+
@pulumi.getter(name="nodePool")
|
|
505
|
+
def node_pool(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
506
|
+
"""
|
|
507
|
+
`(string: <optional>)` - A specific node pool where you would like
|
|
508
|
+
the volume to be created. If you also provide `node_id`, the node must be in the
|
|
509
|
+
provided `node_pool`.
|
|
510
|
+
"""
|
|
511
|
+
return pulumi.get(self, "node_pool")
|
|
512
|
+
|
|
513
|
+
@node_pool.setter
|
|
514
|
+
def node_pool(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
515
|
+
pulumi.set(self, "node_pool", value)
|
|
516
|
+
|
|
517
|
+
@property
|
|
518
|
+
@pulumi.getter
|
|
519
|
+
def parameters(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]:
|
|
520
|
+
"""
|
|
521
|
+
`(map<string|string>: <optional>)` - A key-value map of strings
|
|
522
|
+
passed directly to the plugin to configure the volume. The details of these
|
|
523
|
+
parameters are specific to the plugin.
|
|
524
|
+
"""
|
|
525
|
+
return pulumi.get(self, "parameters")
|
|
526
|
+
|
|
527
|
+
@parameters.setter
|
|
528
|
+
def parameters(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]):
|
|
529
|
+
pulumi.set(self, "parameters", value)
|
|
530
|
+
|
|
531
|
+
@property
|
|
532
|
+
@pulumi.getter(name="pluginId")
|
|
533
|
+
def plugin_id(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
534
|
+
"""
|
|
535
|
+
Plugin ID
|
|
536
|
+
"""
|
|
537
|
+
return pulumi.get(self, "plugin_id")
|
|
538
|
+
|
|
539
|
+
@plugin_id.setter
|
|
540
|
+
def plugin_id(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
541
|
+
pulumi.set(self, "plugin_id", value)
|
|
542
|
+
|
|
543
|
+
@property
|
|
544
|
+
@pulumi.getter
|
|
545
|
+
def state(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
546
|
+
"""
|
|
547
|
+
State
|
|
548
|
+
"""
|
|
549
|
+
return pulumi.get(self, "state")
|
|
550
|
+
|
|
551
|
+
@state.setter
|
|
552
|
+
def state(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
553
|
+
pulumi.set(self, "state", value)
|
|
554
|
+
|
|
555
|
+
|
|
556
|
+
class DynamicHostVolume(pulumi.CustomResource):
|
|
557
|
+
@overload
|
|
558
|
+
def __init__(__self__,
|
|
559
|
+
resource_name: str,
|
|
560
|
+
opts: Optional[pulumi.ResourceOptions] = None,
|
|
561
|
+
capabilities: Optional[pulumi.Input[Sequence[pulumi.Input[Union['DynamicHostVolumeCapabilityArgs', 'DynamicHostVolumeCapabilityArgsDict']]]]] = None,
|
|
562
|
+
capacity_max: Optional[pulumi.Input[builtins.str]] = None,
|
|
563
|
+
capacity_min: Optional[pulumi.Input[builtins.str]] = None,
|
|
564
|
+
constraints: Optional[pulumi.Input[Sequence[pulumi.Input[Union['DynamicHostVolumeConstraintArgs', 'DynamicHostVolumeConstraintArgsDict']]]]] = None,
|
|
565
|
+
name: Optional[pulumi.Input[builtins.str]] = None,
|
|
566
|
+
namespace: Optional[pulumi.Input[builtins.str]] = None,
|
|
567
|
+
node_id: Optional[pulumi.Input[builtins.str]] = None,
|
|
568
|
+
node_pool: Optional[pulumi.Input[builtins.str]] = None,
|
|
569
|
+
parameters: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None,
|
|
570
|
+
plugin_id: Optional[pulumi.Input[builtins.str]] = None,
|
|
571
|
+
__props__=None):
|
|
572
|
+
"""
|
|
573
|
+
layout: "nomad"
|
|
574
|
+
page_title: "Nomad: DynamicHostVolume"
|
|
575
|
+
sidebar_current: "docs-nomad-resource-dynamic-host-volume"
|
|
576
|
+
description: |-
|
|
577
|
+
Manages the lifecycle of creating and deleting dynamic host volumes.
|
|
578
|
+
---
|
|
579
|
+
|
|
580
|
+
Creates and registers a dynamic host volume in Nomad. Note that Nomad supports
|
|
581
|
+
two workflows for dynamic host volumes: create and register. Both resources
|
|
582
|
+
result in the same data source with the same outputs.
|
|
583
|
+
|
|
584
|
+
> **Warning:** Destroying this resource **will result in data loss**. Use the
|
|
585
|
+
[`prevent_destroy`][tf_docs_prevent_destroy] directive to avoid accidental
|
|
586
|
+
deletions.
|
|
587
|
+
|
|
588
|
+
## Example Usage
|
|
589
|
+
|
|
590
|
+
Creating a dynamic host volume:
|
|
591
|
+
|
|
592
|
+
```python
|
|
593
|
+
import pulumi
|
|
594
|
+
import pulumi_nomad as nomad
|
|
595
|
+
|
|
596
|
+
example = nomad.DynamicHostVolume("example",
|
|
597
|
+
name="example",
|
|
598
|
+
namespace="prod",
|
|
599
|
+
plugin_id="mkdir",
|
|
600
|
+
capacity_max="12 GiB",
|
|
601
|
+
capacity_min="1.0 GiB",
|
|
602
|
+
capabilities=[{
|
|
603
|
+
"access_mode": "single-node-writer",
|
|
604
|
+
"attachment_mode": "file-system",
|
|
605
|
+
}],
|
|
606
|
+
constraints=[{
|
|
607
|
+
"attribute": "${attr.kernel.name}",
|
|
608
|
+
"value": "linux",
|
|
609
|
+
}],
|
|
610
|
+
parameters={
|
|
611
|
+
"some_key": "some_value",
|
|
612
|
+
})
|
|
613
|
+
```
|
|
614
|
+
|
|
615
|
+
:param str resource_name: The name of the resource.
|
|
616
|
+
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
617
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['DynamicHostVolumeCapabilityArgs', 'DynamicHostVolumeCapabilityArgsDict']]]] capabilities: `(block: <optional>)` - Option for validating the capability of a
|
|
618
|
+
volume. Each capability block has the following attributes:
|
|
619
|
+
:param pulumi.Input[builtins.str] capacity_max: `(string: <optional>)` - Option for requesting a maximum
|
|
620
|
+
capacity, in bytes. The capacity of a volume may be the physical size of a
|
|
621
|
+
disk, or a quota, depending on the plugin. The specific size of the resulting
|
|
622
|
+
volume is somewhere between `capacity_min` and `capacity_max`; the exact
|
|
623
|
+
behavior is up to the plugin. If you want to specify an exact size, set
|
|
624
|
+
`capacity_min` and `capacity_max` to the same value. Accepts human-friendly
|
|
625
|
+
suffixes such as `"100GiB"`. Plugins that cannot restrict the size of volumes
|
|
626
|
+
may ignore this field.
|
|
627
|
+
:param pulumi.Input[builtins.str] capacity_min: `(string: <optional>)` - Option for requesting a minimum
|
|
628
|
+
capacity, in bytes. The capacity of a volume may be the physical size of a
|
|
629
|
+
disk, or a quota, depending on the plugin. The specific size of the resulting
|
|
630
|
+
volume is somewhere between `capacity_min` and `capacity_max`; the exact
|
|
631
|
+
behavior is up to the plugin. If you want to specify an exact size, set
|
|
632
|
+
`capacity_min` and `capacity_max` to the same value. Accepts human-friendly
|
|
633
|
+
suffixes such as `"100GiB"`. Plugins that cannot restrict the size of volumes
|
|
634
|
+
may ignore this field.
|
|
635
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['DynamicHostVolumeConstraintArgs', 'DynamicHostVolumeConstraintArgsDict']]]] constraints: `(block: <optional>)` - A restriction on the eligible nodes where
|
|
636
|
+
a volume can be created, similar to the [`constraint`][] block on a Nomad job
|
|
637
|
+
specification.. You can provide multiple `constraint` blocks to add more
|
|
638
|
+
constraints. Each constraint block has the following attributes.
|
|
639
|
+
:param pulumi.Input[builtins.str] name: `(string: <required>)` - The name of the volume, which is used as the
|
|
640
|
+
[`volume.source`][volume_source] field in job specifications that claim this
|
|
641
|
+
volume. Host volume names must be unique per node. Names are visible to any
|
|
642
|
+
user with `node:read` ACL, even across namespaces, so they should not be
|
|
643
|
+
treated as sensitive values.
|
|
644
|
+
:param pulumi.Input[builtins.str] namespace: `(string: <optional>)` - The namespace of the volume. This field
|
|
645
|
+
overrides the namespace provided by the `-namespace` flag or `NOMAD_NAMESPACE`
|
|
646
|
+
environment variable. Defaults to `"default"` if unset.
|
|
647
|
+
:param pulumi.Input[builtins.str] node_id: `(string: <optional>)` - A specific node where you would like the
|
|
648
|
+
volume to be created.
|
|
649
|
+
:param pulumi.Input[builtins.str] node_pool: `(string: <optional>)` - A specific node pool where you would like
|
|
650
|
+
the volume to be created. If you also provide `node_id`, the node must be in the
|
|
651
|
+
provided `node_pool`.
|
|
652
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] parameters: `(map<string|string>: <optional>)` - A key-value map of strings
|
|
653
|
+
passed directly to the plugin to configure the volume. The details of these
|
|
654
|
+
parameters are specific to the plugin.
|
|
655
|
+
:param pulumi.Input[builtins.str] plugin_id: Plugin ID
|
|
656
|
+
"""
|
|
657
|
+
...
|
|
658
|
+
@overload
|
|
659
|
+
def __init__(__self__,
|
|
660
|
+
resource_name: str,
|
|
661
|
+
args: DynamicHostVolumeArgs,
|
|
662
|
+
opts: Optional[pulumi.ResourceOptions] = None):
|
|
663
|
+
"""
|
|
664
|
+
layout: "nomad"
|
|
665
|
+
page_title: "Nomad: DynamicHostVolume"
|
|
666
|
+
sidebar_current: "docs-nomad-resource-dynamic-host-volume"
|
|
667
|
+
description: |-
|
|
668
|
+
Manages the lifecycle of creating and deleting dynamic host volumes.
|
|
669
|
+
---
|
|
670
|
+
|
|
671
|
+
Creates and registers a dynamic host volume in Nomad. Note that Nomad supports
|
|
672
|
+
two workflows for dynamic host volumes: create and register. Both resources
|
|
673
|
+
result in the same data source with the same outputs.
|
|
674
|
+
|
|
675
|
+
> **Warning:** Destroying this resource **will result in data loss**. Use the
|
|
676
|
+
[`prevent_destroy`][tf_docs_prevent_destroy] directive to avoid accidental
|
|
677
|
+
deletions.
|
|
678
|
+
|
|
679
|
+
## Example Usage
|
|
680
|
+
|
|
681
|
+
Creating a dynamic host volume:
|
|
682
|
+
|
|
683
|
+
```python
|
|
684
|
+
import pulumi
|
|
685
|
+
import pulumi_nomad as nomad
|
|
686
|
+
|
|
687
|
+
example = nomad.DynamicHostVolume("example",
|
|
688
|
+
name="example",
|
|
689
|
+
namespace="prod",
|
|
690
|
+
plugin_id="mkdir",
|
|
691
|
+
capacity_max="12 GiB",
|
|
692
|
+
capacity_min="1.0 GiB",
|
|
693
|
+
capabilities=[{
|
|
694
|
+
"access_mode": "single-node-writer",
|
|
695
|
+
"attachment_mode": "file-system",
|
|
696
|
+
}],
|
|
697
|
+
constraints=[{
|
|
698
|
+
"attribute": "${attr.kernel.name}",
|
|
699
|
+
"value": "linux",
|
|
700
|
+
}],
|
|
701
|
+
parameters={
|
|
702
|
+
"some_key": "some_value",
|
|
703
|
+
})
|
|
704
|
+
```
|
|
705
|
+
|
|
706
|
+
:param str resource_name: The name of the resource.
|
|
707
|
+
:param DynamicHostVolumeArgs args: The arguments to use to populate this resource's properties.
|
|
708
|
+
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
709
|
+
"""
|
|
710
|
+
...
|
|
711
|
+
def __init__(__self__, resource_name: str, *args, **kwargs):
|
|
712
|
+
resource_args, opts = _utilities.get_resource_args_opts(DynamicHostVolumeArgs, pulumi.ResourceOptions, *args, **kwargs)
|
|
713
|
+
if resource_args is not None:
|
|
714
|
+
__self__._internal_init(resource_name, opts, **resource_args.__dict__)
|
|
715
|
+
else:
|
|
716
|
+
__self__._internal_init(resource_name, *args, **kwargs)
|
|
717
|
+
|
|
718
|
+
def _internal_init(__self__,
|
|
719
|
+
resource_name: str,
|
|
720
|
+
opts: Optional[pulumi.ResourceOptions] = None,
|
|
721
|
+
capabilities: Optional[pulumi.Input[Sequence[pulumi.Input[Union['DynamicHostVolumeCapabilityArgs', 'DynamicHostVolumeCapabilityArgsDict']]]]] = None,
|
|
722
|
+
capacity_max: Optional[pulumi.Input[builtins.str]] = None,
|
|
723
|
+
capacity_min: Optional[pulumi.Input[builtins.str]] = None,
|
|
724
|
+
constraints: Optional[pulumi.Input[Sequence[pulumi.Input[Union['DynamicHostVolumeConstraintArgs', 'DynamicHostVolumeConstraintArgsDict']]]]] = None,
|
|
725
|
+
name: Optional[pulumi.Input[builtins.str]] = None,
|
|
726
|
+
namespace: Optional[pulumi.Input[builtins.str]] = None,
|
|
727
|
+
node_id: Optional[pulumi.Input[builtins.str]] = None,
|
|
728
|
+
node_pool: Optional[pulumi.Input[builtins.str]] = None,
|
|
729
|
+
parameters: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None,
|
|
730
|
+
plugin_id: Optional[pulumi.Input[builtins.str]] = None,
|
|
731
|
+
__props__=None):
|
|
732
|
+
opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
|
|
733
|
+
if not isinstance(opts, pulumi.ResourceOptions):
|
|
734
|
+
raise TypeError('Expected resource options to be a ResourceOptions instance')
|
|
735
|
+
if opts.id is None:
|
|
736
|
+
if __props__ is not None:
|
|
737
|
+
raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource')
|
|
738
|
+
__props__ = DynamicHostVolumeArgs.__new__(DynamicHostVolumeArgs)
|
|
739
|
+
|
|
740
|
+
if capabilities is None and not opts.urn:
|
|
741
|
+
raise TypeError("Missing required property 'capabilities'")
|
|
742
|
+
__props__.__dict__["capabilities"] = capabilities
|
|
743
|
+
__props__.__dict__["capacity_max"] = capacity_max
|
|
744
|
+
__props__.__dict__["capacity_min"] = capacity_min
|
|
745
|
+
__props__.__dict__["constraints"] = constraints
|
|
746
|
+
__props__.__dict__["name"] = name
|
|
747
|
+
__props__.__dict__["namespace"] = namespace
|
|
748
|
+
__props__.__dict__["node_id"] = node_id
|
|
749
|
+
__props__.__dict__["node_pool"] = node_pool
|
|
750
|
+
__props__.__dict__["parameters"] = parameters
|
|
751
|
+
if plugin_id is None and not opts.urn:
|
|
752
|
+
raise TypeError("Missing required property 'plugin_id'")
|
|
753
|
+
__props__.__dict__["plugin_id"] = plugin_id
|
|
754
|
+
__props__.__dict__["capacity"] = None
|
|
755
|
+
__props__.__dict__["capacity_bytes"] = None
|
|
756
|
+
__props__.__dict__["capacity_max_bytes"] = None
|
|
757
|
+
__props__.__dict__["capacity_min_bytes"] = None
|
|
758
|
+
__props__.__dict__["host_path"] = None
|
|
759
|
+
__props__.__dict__["state"] = None
|
|
760
|
+
super(DynamicHostVolume, __self__).__init__(
|
|
761
|
+
'nomad:index/dynamicHostVolume:DynamicHostVolume',
|
|
762
|
+
resource_name,
|
|
763
|
+
__props__,
|
|
764
|
+
opts)
|
|
765
|
+
|
|
766
|
+
@staticmethod
|
|
767
|
+
def get(resource_name: str,
|
|
768
|
+
id: pulumi.Input[str],
|
|
769
|
+
opts: Optional[pulumi.ResourceOptions] = None,
|
|
770
|
+
capabilities: Optional[pulumi.Input[Sequence[pulumi.Input[Union['DynamicHostVolumeCapabilityArgs', 'DynamicHostVolumeCapabilityArgsDict']]]]] = None,
|
|
771
|
+
capacity: Optional[pulumi.Input[builtins.str]] = None,
|
|
772
|
+
capacity_bytes: Optional[pulumi.Input[builtins.int]] = None,
|
|
773
|
+
capacity_max: Optional[pulumi.Input[builtins.str]] = None,
|
|
774
|
+
capacity_max_bytes: Optional[pulumi.Input[builtins.int]] = None,
|
|
775
|
+
capacity_min: Optional[pulumi.Input[builtins.str]] = None,
|
|
776
|
+
capacity_min_bytes: Optional[pulumi.Input[builtins.int]] = None,
|
|
777
|
+
constraints: Optional[pulumi.Input[Sequence[pulumi.Input[Union['DynamicHostVolumeConstraintArgs', 'DynamicHostVolumeConstraintArgsDict']]]]] = None,
|
|
778
|
+
host_path: Optional[pulumi.Input[builtins.str]] = None,
|
|
779
|
+
name: Optional[pulumi.Input[builtins.str]] = None,
|
|
780
|
+
namespace: Optional[pulumi.Input[builtins.str]] = None,
|
|
781
|
+
node_id: Optional[pulumi.Input[builtins.str]] = None,
|
|
782
|
+
node_pool: Optional[pulumi.Input[builtins.str]] = None,
|
|
783
|
+
parameters: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None,
|
|
784
|
+
plugin_id: Optional[pulumi.Input[builtins.str]] = None,
|
|
785
|
+
state: Optional[pulumi.Input[builtins.str]] = None) -> 'DynamicHostVolume':
|
|
786
|
+
"""
|
|
787
|
+
Get an existing DynamicHostVolume resource's state with the given name, id, and optional extra
|
|
788
|
+
properties used to qualify the lookup.
|
|
789
|
+
|
|
790
|
+
:param str resource_name: The unique name of the resulting resource.
|
|
791
|
+
:param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
|
|
792
|
+
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
793
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['DynamicHostVolumeCapabilityArgs', 'DynamicHostVolumeCapabilityArgsDict']]]] capabilities: `(block: <optional>)` - Option for validating the capability of a
|
|
794
|
+
volume. Each capability block has the following attributes:
|
|
795
|
+
:param pulumi.Input[builtins.str] capacity: Provisioned capacity
|
|
796
|
+
:param pulumi.Input[builtins.str] capacity_max: `(string: <optional>)` - Option for requesting a maximum
|
|
797
|
+
capacity, in bytes. The capacity of a volume may be the physical size of a
|
|
798
|
+
disk, or a quota, depending on the plugin. The specific size of the resulting
|
|
799
|
+
volume is somewhere between `capacity_min` and `capacity_max`; the exact
|
|
800
|
+
behavior is up to the plugin. If you want to specify an exact size, set
|
|
801
|
+
`capacity_min` and `capacity_max` to the same value. Accepts human-friendly
|
|
802
|
+
suffixes such as `"100GiB"`. Plugins that cannot restrict the size of volumes
|
|
803
|
+
may ignore this field.
|
|
804
|
+
:param pulumi.Input[builtins.str] capacity_min: `(string: <optional>)` - Option for requesting a minimum
|
|
805
|
+
capacity, in bytes. The capacity of a volume may be the physical size of a
|
|
806
|
+
disk, or a quota, depending on the plugin. The specific size of the resulting
|
|
807
|
+
volume is somewhere between `capacity_min` and `capacity_max`; the exact
|
|
808
|
+
behavior is up to the plugin. If you want to specify an exact size, set
|
|
809
|
+
`capacity_min` and `capacity_max` to the same value. Accepts human-friendly
|
|
810
|
+
suffixes such as `"100GiB"`. Plugins that cannot restrict the size of volumes
|
|
811
|
+
may ignore this field.
|
|
812
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['DynamicHostVolumeConstraintArgs', 'DynamicHostVolumeConstraintArgsDict']]]] constraints: `(block: <optional>)` - A restriction on the eligible nodes where
|
|
813
|
+
a volume can be created, similar to the [`constraint`][] block on a Nomad job
|
|
814
|
+
specification.. You can provide multiple `constraint` blocks to add more
|
|
815
|
+
constraints. Each constraint block has the following attributes.
|
|
816
|
+
:param pulumi.Input[builtins.str] host_path: Host path
|
|
817
|
+
:param pulumi.Input[builtins.str] name: `(string: <required>)` - The name of the volume, which is used as the
|
|
818
|
+
[`volume.source`][volume_source] field in job specifications that claim this
|
|
819
|
+
volume. Host volume names must be unique per node. Names are visible to any
|
|
820
|
+
user with `node:read` ACL, even across namespaces, so they should not be
|
|
821
|
+
treated as sensitive values.
|
|
822
|
+
:param pulumi.Input[builtins.str] namespace: `(string: <optional>)` - The namespace of the volume. This field
|
|
823
|
+
overrides the namespace provided by the `-namespace` flag or `NOMAD_NAMESPACE`
|
|
824
|
+
environment variable. Defaults to `"default"` if unset.
|
|
825
|
+
:param pulumi.Input[builtins.str] node_id: `(string: <optional>)` - A specific node where you would like the
|
|
826
|
+
volume to be created.
|
|
827
|
+
:param pulumi.Input[builtins.str] node_pool: `(string: <optional>)` - A specific node pool where you would like
|
|
828
|
+
the volume to be created. If you also provide `node_id`, the node must be in the
|
|
829
|
+
provided `node_pool`.
|
|
830
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] parameters: `(map<string|string>: <optional>)` - A key-value map of strings
|
|
831
|
+
passed directly to the plugin to configure the volume. The details of these
|
|
832
|
+
parameters are specific to the plugin.
|
|
833
|
+
:param pulumi.Input[builtins.str] plugin_id: Plugin ID
|
|
834
|
+
:param pulumi.Input[builtins.str] state: State
|
|
835
|
+
"""
|
|
836
|
+
opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
|
|
837
|
+
|
|
838
|
+
__props__ = _DynamicHostVolumeState.__new__(_DynamicHostVolumeState)
|
|
839
|
+
|
|
840
|
+
__props__.__dict__["capabilities"] = capabilities
|
|
841
|
+
__props__.__dict__["capacity"] = capacity
|
|
842
|
+
__props__.__dict__["capacity_bytes"] = capacity_bytes
|
|
843
|
+
__props__.__dict__["capacity_max"] = capacity_max
|
|
844
|
+
__props__.__dict__["capacity_max_bytes"] = capacity_max_bytes
|
|
845
|
+
__props__.__dict__["capacity_min"] = capacity_min
|
|
846
|
+
__props__.__dict__["capacity_min_bytes"] = capacity_min_bytes
|
|
847
|
+
__props__.__dict__["constraints"] = constraints
|
|
848
|
+
__props__.__dict__["host_path"] = host_path
|
|
849
|
+
__props__.__dict__["name"] = name
|
|
850
|
+
__props__.__dict__["namespace"] = namespace
|
|
851
|
+
__props__.__dict__["node_id"] = node_id
|
|
852
|
+
__props__.__dict__["node_pool"] = node_pool
|
|
853
|
+
__props__.__dict__["parameters"] = parameters
|
|
854
|
+
__props__.__dict__["plugin_id"] = plugin_id
|
|
855
|
+
__props__.__dict__["state"] = state
|
|
856
|
+
return DynamicHostVolume(resource_name, opts=opts, __props__=__props__)
|
|
857
|
+
|
|
858
|
+
@property
|
|
859
|
+
@pulumi.getter
|
|
860
|
+
def capabilities(self) -> pulumi.Output[Sequence['outputs.DynamicHostVolumeCapability']]:
|
|
861
|
+
"""
|
|
862
|
+
`(block: <optional>)` - Option for validating the capability of a
|
|
863
|
+
volume. Each capability block has the following attributes:
|
|
864
|
+
"""
|
|
865
|
+
return pulumi.get(self, "capabilities")
|
|
866
|
+
|
|
867
|
+
@property
|
|
868
|
+
@pulumi.getter
|
|
869
|
+
def capacity(self) -> pulumi.Output[builtins.str]:
|
|
870
|
+
"""
|
|
871
|
+
Provisioned capacity
|
|
872
|
+
"""
|
|
873
|
+
return pulumi.get(self, "capacity")
|
|
874
|
+
|
|
875
|
+
@property
|
|
876
|
+
@pulumi.getter(name="capacityBytes")
|
|
877
|
+
def capacity_bytes(self) -> pulumi.Output[builtins.int]:
|
|
878
|
+
return pulumi.get(self, "capacity_bytes")
|
|
879
|
+
|
|
880
|
+
@property
|
|
881
|
+
@pulumi.getter(name="capacityMax")
|
|
882
|
+
def capacity_max(self) -> pulumi.Output[Optional[builtins.str]]:
|
|
883
|
+
"""
|
|
884
|
+
`(string: <optional>)` - Option for requesting a maximum
|
|
885
|
+
capacity, in bytes. The capacity of a volume may be the physical size of a
|
|
886
|
+
disk, or a quota, depending on the plugin. The specific size of the resulting
|
|
887
|
+
volume is somewhere between `capacity_min` and `capacity_max`; the exact
|
|
888
|
+
behavior is up to the plugin. If you want to specify an exact size, set
|
|
889
|
+
`capacity_min` and `capacity_max` to the same value. Accepts human-friendly
|
|
890
|
+
suffixes such as `"100GiB"`. Plugins that cannot restrict the size of volumes
|
|
891
|
+
may ignore this field.
|
|
892
|
+
"""
|
|
893
|
+
return pulumi.get(self, "capacity_max")
|
|
894
|
+
|
|
895
|
+
@property
|
|
896
|
+
@pulumi.getter(name="capacityMaxBytes")
|
|
897
|
+
def capacity_max_bytes(self) -> pulumi.Output[builtins.int]:
|
|
898
|
+
return pulumi.get(self, "capacity_max_bytes")
|
|
899
|
+
|
|
900
|
+
@property
|
|
901
|
+
@pulumi.getter(name="capacityMin")
|
|
902
|
+
def capacity_min(self) -> pulumi.Output[Optional[builtins.str]]:
|
|
903
|
+
"""
|
|
904
|
+
`(string: <optional>)` - Option for requesting a minimum
|
|
905
|
+
capacity, in bytes. The capacity of a volume may be the physical size of a
|
|
906
|
+
disk, or a quota, depending on the plugin. The specific size of the resulting
|
|
907
|
+
volume is somewhere between `capacity_min` and `capacity_max`; the exact
|
|
908
|
+
behavior is up to the plugin. If you want to specify an exact size, set
|
|
909
|
+
`capacity_min` and `capacity_max` to the same value. Accepts human-friendly
|
|
910
|
+
suffixes such as `"100GiB"`. Plugins that cannot restrict the size of volumes
|
|
911
|
+
may ignore this field.
|
|
912
|
+
"""
|
|
913
|
+
return pulumi.get(self, "capacity_min")
|
|
914
|
+
|
|
915
|
+
@property
|
|
916
|
+
@pulumi.getter(name="capacityMinBytes")
|
|
917
|
+
def capacity_min_bytes(self) -> pulumi.Output[builtins.int]:
|
|
918
|
+
return pulumi.get(self, "capacity_min_bytes")
|
|
919
|
+
|
|
920
|
+
@property
|
|
921
|
+
@pulumi.getter
|
|
922
|
+
def constraints(self) -> pulumi.Output[Optional[Sequence['outputs.DynamicHostVolumeConstraint']]]:
|
|
923
|
+
"""
|
|
924
|
+
`(block: <optional>)` - A restriction on the eligible nodes where
|
|
925
|
+
a volume can be created, similar to the [`constraint`][] block on a Nomad job
|
|
926
|
+
specification.. You can provide multiple `constraint` blocks to add more
|
|
927
|
+
constraints. Each constraint block has the following attributes.
|
|
928
|
+
"""
|
|
929
|
+
return pulumi.get(self, "constraints")
|
|
930
|
+
|
|
931
|
+
@property
|
|
932
|
+
@pulumi.getter(name="hostPath")
|
|
933
|
+
def host_path(self) -> pulumi.Output[builtins.str]:
|
|
934
|
+
"""
|
|
935
|
+
Host path
|
|
936
|
+
"""
|
|
937
|
+
return pulumi.get(self, "host_path")
|
|
938
|
+
|
|
939
|
+
@property
|
|
940
|
+
@pulumi.getter
|
|
941
|
+
def name(self) -> pulumi.Output[builtins.str]:
|
|
942
|
+
"""
|
|
943
|
+
`(string: <required>)` - The name of the volume, which is used as the
|
|
944
|
+
[`volume.source`][volume_source] field in job specifications that claim this
|
|
945
|
+
volume. Host volume names must be unique per node. Names are visible to any
|
|
946
|
+
user with `node:read` ACL, even across namespaces, so they should not be
|
|
947
|
+
treated as sensitive values.
|
|
948
|
+
"""
|
|
949
|
+
return pulumi.get(self, "name")
|
|
950
|
+
|
|
951
|
+
@property
|
|
952
|
+
@pulumi.getter
|
|
953
|
+
def namespace(self) -> pulumi.Output[Optional[builtins.str]]:
|
|
954
|
+
"""
|
|
955
|
+
`(string: <optional>)` - The namespace of the volume. This field
|
|
956
|
+
overrides the namespace provided by the `-namespace` flag or `NOMAD_NAMESPACE`
|
|
957
|
+
environment variable. Defaults to `"default"` if unset.
|
|
958
|
+
"""
|
|
959
|
+
return pulumi.get(self, "namespace")
|
|
960
|
+
|
|
961
|
+
@property
|
|
962
|
+
@pulumi.getter(name="nodeId")
|
|
963
|
+
def node_id(self) -> pulumi.Output[builtins.str]:
|
|
964
|
+
"""
|
|
965
|
+
`(string: <optional>)` - A specific node where you would like the
|
|
966
|
+
volume to be created.
|
|
967
|
+
"""
|
|
968
|
+
return pulumi.get(self, "node_id")
|
|
969
|
+
|
|
970
|
+
@property
|
|
971
|
+
@pulumi.getter(name="nodePool")
|
|
972
|
+
def node_pool(self) -> pulumi.Output[builtins.str]:
|
|
973
|
+
"""
|
|
974
|
+
`(string: <optional>)` - A specific node pool where you would like
|
|
975
|
+
the volume to be created. If you also provide `node_id`, the node must be in the
|
|
976
|
+
provided `node_pool`.
|
|
977
|
+
"""
|
|
978
|
+
return pulumi.get(self, "node_pool")
|
|
979
|
+
|
|
980
|
+
@property
|
|
981
|
+
@pulumi.getter
|
|
982
|
+
def parameters(self) -> pulumi.Output[Optional[Mapping[str, builtins.str]]]:
|
|
983
|
+
"""
|
|
984
|
+
`(map<string|string>: <optional>)` - A key-value map of strings
|
|
985
|
+
passed directly to the plugin to configure the volume. The details of these
|
|
986
|
+
parameters are specific to the plugin.
|
|
987
|
+
"""
|
|
988
|
+
return pulumi.get(self, "parameters")
|
|
989
|
+
|
|
990
|
+
@property
|
|
991
|
+
@pulumi.getter(name="pluginId")
|
|
992
|
+
def plugin_id(self) -> pulumi.Output[builtins.str]:
|
|
993
|
+
"""
|
|
994
|
+
Plugin ID
|
|
995
|
+
"""
|
|
996
|
+
return pulumi.get(self, "plugin_id")
|
|
997
|
+
|
|
998
|
+
@property
|
|
999
|
+
@pulumi.getter
|
|
1000
|
+
def state(self) -> pulumi.Output[builtins.str]:
|
|
1001
|
+
"""
|
|
1002
|
+
State
|
|
1003
|
+
"""
|
|
1004
|
+
return pulumi.get(self, "state")
|
|
1005
|
+
|