pulumi-kubernetes 4.23.0a1746131759__py3-none-any.whl → 4.23.0a1746138483__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-kubernetes might be problematic. Click here for more details.
- pulumi_kubernetes/__init__.py +36 -2
- pulumi_kubernetes/admissionregistration/v1alpha1/_inputs.py +30 -30
- pulumi_kubernetes/admissionregistration/v1alpha1/outputs.py +20 -20
- pulumi_kubernetes/apps/v1/ReplicaSetList.py +4 -4
- pulumi_kubernetes/apps/v1/_inputs.py +109 -56
- pulumi_kubernetes/apps/v1/outputs.py +129 -56
- pulumi_kubernetes/autoscaling/v2/_inputs.py +92 -12
- pulumi_kubernetes/autoscaling/v2/outputs.py +66 -10
- pulumi_kubernetes/batch/v1/_inputs.py +12 -42
- pulumi_kubernetes/batch/v1/outputs.py +8 -32
- pulumi_kubernetes/certificates/v1alpha1/ClusterTrustBundle.py +2 -0
- pulumi_kubernetes/certificates/v1alpha1/ClusterTrustBundlePatch.py +2 -0
- pulumi_kubernetes/certificates/v1beta1/ClusterTrustBundle.py +229 -0
- pulumi_kubernetes/certificates/v1beta1/ClusterTrustBundleList.py +219 -0
- pulumi_kubernetes/certificates/v1beta1/ClusterTrustBundlePatch.py +240 -0
- pulumi_kubernetes/certificates/v1beta1/__init__.py +3 -0
- pulumi_kubernetes/certificates/v1beta1/_inputs.py +292 -0
- pulumi_kubernetes/certificates/v1beta1/outputs.py +241 -0
- pulumi_kubernetes/coordination/v1alpha1/LeaseCandidate.py +1 -1
- pulumi_kubernetes/coordination/v1alpha1/LeaseCandidatePatch.py +1 -1
- pulumi_kubernetes/coordination/v1alpha2/LeaseCandidate.py +1 -1
- pulumi_kubernetes/coordination/v1alpha2/LeaseCandidatePatch.py +1 -1
- pulumi_kubernetes/coordination/v1alpha2/_inputs.py +6 -6
- pulumi_kubernetes/coordination/v1alpha2/outputs.py +4 -4
- pulumi_kubernetes/coordination/v1beta1/LeaseCandidate.py +220 -0
- pulumi_kubernetes/coordination/v1beta1/LeaseCandidateList.py +219 -0
- pulumi_kubernetes/coordination/v1beta1/LeaseCandidatePatch.py +232 -0
- pulumi_kubernetes/coordination/v1beta1/__init__.py +3 -0
- pulumi_kubernetes/coordination/v1beta1/_inputs.py +371 -0
- pulumi_kubernetes/coordination/v1beta1/outputs.py +292 -0
- pulumi_kubernetes/core/v1/Endpoints.py +8 -0
- pulumi_kubernetes/core/v1/EndpointsList.py +2 -2
- pulumi_kubernetes/core/v1/EndpointsPatch.py +8 -0
- pulumi_kubernetes/core/v1/_inputs.py +240 -66
- pulumi_kubernetes/core/v1/outputs.py +251 -51
- pulumi_kubernetes/discovery/v1/EndpointSlice.py +10 -10
- pulumi_kubernetes/discovery/v1/EndpointSlicePatch.py +10 -10
- pulumi_kubernetes/discovery/v1/_inputs.py +159 -44
- pulumi_kubernetes/discovery/v1/outputs.py +107 -32
- pulumi_kubernetes/networking/v1/IPAddress.py +220 -0
- pulumi_kubernetes/networking/v1/IPAddressList.py +219 -0
- pulumi_kubernetes/networking/v1/IPAddressPatch.py +232 -0
- pulumi_kubernetes/networking/v1/ServiceCIDR.py +230 -0
- pulumi_kubernetes/networking/v1/ServiceCIDRList.py +219 -0
- pulumi_kubernetes/networking/v1/ServiceCIDRPatch.py +242 -0
- pulumi_kubernetes/networking/v1/__init__.py +6 -0
- pulumi_kubernetes/networking/v1/_inputs.py +599 -0
- pulumi_kubernetes/networking/v1/outputs.py +461 -0
- pulumi_kubernetes/networking/v1alpha1/IPAddress.py +1 -1
- pulumi_kubernetes/networking/v1alpha1/IPAddressPatch.py +1 -1
- pulumi_kubernetes/networking/v1alpha1/ServiceCIDR.py +1 -1
- pulumi_kubernetes/networking/v1alpha1/ServiceCIDRPatch.py +1 -1
- pulumi_kubernetes/networking/v1beta1/IPAddress.py +1 -1
- pulumi_kubernetes/networking/v1beta1/IPAddressPatch.py +1 -1
- pulumi_kubernetes/networking/v1beta1/ServiceCIDR.py +1 -1
- pulumi_kubernetes/networking/v1beta1/ServiceCIDRPatch.py +1 -1
- pulumi_kubernetes/policy/v1/_inputs.py +0 -12
- pulumi_kubernetes/policy/v1/outputs.py +0 -8
- pulumi_kubernetes/pulumi-plugin.json +1 -1
- pulumi_kubernetes/resource/__init__.py +3 -0
- pulumi_kubernetes/resource/v1alpha1/ResourceClaim.py +1 -1
- pulumi_kubernetes/resource/v1alpha1/ResourceClaimPatch.py +1 -1
- pulumi_kubernetes/resource/v1alpha1/ResourceClaimTemplate.py +1 -1
- pulumi_kubernetes/resource/v1alpha1/ResourceClaimTemplatePatch.py +1 -1
- pulumi_kubernetes/resource/v1alpha2/ResourceClaim.py +1 -1
- pulumi_kubernetes/resource/v1alpha2/ResourceClaimPatch.py +1 -1
- pulumi_kubernetes/resource/v1alpha2/ResourceClaimTemplate.py +1 -1
- pulumi_kubernetes/resource/v1alpha2/ResourceClaimTemplatePatch.py +1 -1
- pulumi_kubernetes/resource/v1alpha2/ResourceSlice.py +1 -1
- pulumi_kubernetes/resource/v1alpha2/ResourceSlicePatch.py +1 -1
- pulumi_kubernetes/resource/v1alpha3/DeviceClass.py +1 -1
- pulumi_kubernetes/resource/v1alpha3/DeviceClassPatch.py +1 -1
- pulumi_kubernetes/resource/v1alpha3/DeviceTaintRule.py +227 -0
- pulumi_kubernetes/resource/v1alpha3/DeviceTaintRuleList.py +219 -0
- pulumi_kubernetes/resource/v1alpha3/DeviceTaintRulePatch.py +238 -0
- pulumi_kubernetes/resource/v1alpha3/ResourceClaim.py +1 -1
- pulumi_kubernetes/resource/v1alpha3/ResourceClaimPatch.py +1 -1
- pulumi_kubernetes/resource/v1alpha3/ResourceClaimTemplate.py +1 -1
- pulumi_kubernetes/resource/v1alpha3/ResourceClaimTemplatePatch.py +1 -1
- pulumi_kubernetes/resource/v1alpha3/ResourceSlice.py +1 -1
- pulumi_kubernetes/resource/v1alpha3/ResourceSlicePatch.py +1 -1
- pulumi_kubernetes/resource/v1alpha3/__init__.py +3 -0
- pulumi_kubernetes/resource/v1alpha3/_inputs.py +2559 -213
- pulumi_kubernetes/resource/v1alpha3/outputs.py +2037 -256
- pulumi_kubernetes/resource/v1beta1/DeviceClass.py +1 -1
- pulumi_kubernetes/resource/v1beta1/DeviceClassPatch.py +1 -1
- pulumi_kubernetes/resource/v1beta1/ResourceClaim.py +1 -1
- pulumi_kubernetes/resource/v1beta1/ResourceClaimPatch.py +1 -1
- pulumi_kubernetes/resource/v1beta1/ResourceClaimTemplate.py +1 -1
- pulumi_kubernetes/resource/v1beta1/ResourceClaimTemplatePatch.py +1 -1
- pulumi_kubernetes/resource/v1beta1/ResourceSlice.py +1 -1
- pulumi_kubernetes/resource/v1beta1/ResourceSlicePatch.py +1 -1
- pulumi_kubernetes/resource/v1beta1/_inputs.py +2044 -176
- pulumi_kubernetes/resource/v1beta1/outputs.py +1536 -134
- pulumi_kubernetes/resource/v1beta2/DeviceClass.py +241 -0
- pulumi_kubernetes/resource/v1beta2/DeviceClassList.py +219 -0
- pulumi_kubernetes/resource/v1beta2/DeviceClassPatch.py +252 -0
- pulumi_kubernetes/resource/v1beta2/ResourceClaim.py +236 -0
- pulumi_kubernetes/resource/v1beta2/ResourceClaimList.py +220 -0
- pulumi_kubernetes/resource/v1beta2/ResourceClaimPatch.py +247 -0
- pulumi_kubernetes/resource/v1beta2/ResourceClaimTemplate.py +233 -0
- pulumi_kubernetes/resource/v1beta2/ResourceClaimTemplateList.py +219 -0
- pulumi_kubernetes/resource/v1beta2/ResourceClaimTemplatePatch.py +244 -0
- pulumi_kubernetes/resource/v1beta2/ResourceSlice.py +250 -0
- pulumi_kubernetes/resource/v1beta2/ResourceSliceList.py +220 -0
- pulumi_kubernetes/resource/v1beta2/ResourceSlicePatch.py +261 -0
- pulumi_kubernetes/resource/v1beta2/__init__.py +22 -0
- pulumi_kubernetes/resource/v1beta2/_inputs.py +5681 -0
- pulumi_kubernetes/resource/v1beta2/outputs.py +4726 -0
- pulumi_kubernetes/storage/v1/_inputs.py +90 -0
- pulumi_kubernetes/storage/v1/outputs.py +110 -0
- pulumi_kubernetes/yaml/yaml.py +108 -0
- {pulumi_kubernetes-4.23.0a1746131759.dist-info → pulumi_kubernetes-4.23.0a1746138483.dist-info}/METADATA +1 -1
- {pulumi_kubernetes-4.23.0a1746131759.dist-info → pulumi_kubernetes-4.23.0a1746138483.dist-info}/RECORD +116 -86
- {pulumi_kubernetes-4.23.0a1746131759.dist-info → pulumi_kubernetes-4.23.0a1746138483.dist-info}/WHEEL +0 -0
- {pulumi_kubernetes-4.23.0a1746131759.dist-info → pulumi_kubernetes-4.23.0a1746138483.dist-info}/top_level.txt +0 -0
|
@@ -30,6 +30,12 @@ __all__ = [
|
|
|
30
30
|
'CELDeviceSelectorPatchArgsDict',
|
|
31
31
|
'CELDeviceSelectorArgs',
|
|
32
32
|
'CELDeviceSelectorArgsDict',
|
|
33
|
+
'CounterSetPatchArgs',
|
|
34
|
+
'CounterSetPatchArgsDict',
|
|
35
|
+
'CounterSetArgs',
|
|
36
|
+
'CounterSetArgsDict',
|
|
37
|
+
'CounterArgs',
|
|
38
|
+
'CounterArgsDict',
|
|
33
39
|
'DeviceAllocationConfigurationArgs',
|
|
34
40
|
'DeviceAllocationConfigurationArgsDict',
|
|
35
41
|
'DeviceAllocationResultArgs',
|
|
@@ -60,6 +66,10 @@ __all__ = [
|
|
|
60
66
|
'DeviceConstraintPatchArgsDict',
|
|
61
67
|
'DeviceConstraintArgs',
|
|
62
68
|
'DeviceConstraintArgsDict',
|
|
69
|
+
'DeviceCounterConsumptionPatchArgs',
|
|
70
|
+
'DeviceCounterConsumptionPatchArgsDict',
|
|
71
|
+
'DeviceCounterConsumptionArgs',
|
|
72
|
+
'DeviceCounterConsumptionArgsDict',
|
|
63
73
|
'DevicePatchArgs',
|
|
64
74
|
'DevicePatchArgsDict',
|
|
65
75
|
'DeviceRequestAllocationResultArgs',
|
|
@@ -72,6 +82,18 @@ __all__ = [
|
|
|
72
82
|
'DeviceSelectorPatchArgsDict',
|
|
73
83
|
'DeviceSelectorArgs',
|
|
74
84
|
'DeviceSelectorArgsDict',
|
|
85
|
+
'DeviceSubRequestPatchArgs',
|
|
86
|
+
'DeviceSubRequestPatchArgsDict',
|
|
87
|
+
'DeviceSubRequestArgs',
|
|
88
|
+
'DeviceSubRequestArgsDict',
|
|
89
|
+
'DeviceTaintPatchArgs',
|
|
90
|
+
'DeviceTaintPatchArgsDict',
|
|
91
|
+
'DeviceTaintArgs',
|
|
92
|
+
'DeviceTaintArgsDict',
|
|
93
|
+
'DeviceTolerationPatchArgs',
|
|
94
|
+
'DeviceTolerationPatchArgsDict',
|
|
95
|
+
'DeviceTolerationArgs',
|
|
96
|
+
'DeviceTolerationArgsDict',
|
|
75
97
|
'DeviceArgs',
|
|
76
98
|
'DeviceArgsDict',
|
|
77
99
|
'NetworkDeviceDataArgs',
|
|
@@ -134,6 +156,8 @@ if not MYPY:
|
|
|
134
156
|
conditions: NotRequired[pulumi.Input[Sequence[pulumi.Input['_meta.v1.ConditionArgsDict']]]]
|
|
135
157
|
"""
|
|
136
158
|
Conditions contains the latest observation of the device's state. If the device has been configured according to the class and claim config references, the `Ready` condition should be True.
|
|
159
|
+
|
|
160
|
+
Must not contain more than 8 entries.
|
|
137
161
|
"""
|
|
138
162
|
data: NotRequired[Any]
|
|
139
163
|
"""
|
|
@@ -167,6 +191,8 @@ class AllocatedDeviceStatusArgs:
|
|
|
167
191
|
|
|
168
192
|
Must not be longer than 253 characters and may contain one or more DNS sub-domains separated by slashes.
|
|
169
193
|
:param pulumi.Input[Sequence[pulumi.Input['_meta.v1.ConditionArgs']]] conditions: Conditions contains the latest observation of the device's state. If the device has been configured according to the class and claim config references, the `Ready` condition should be True.
|
|
194
|
+
|
|
195
|
+
Must not contain more than 8 entries.
|
|
170
196
|
:param Any data: Data contains arbitrary driver-specific data.
|
|
171
197
|
|
|
172
198
|
The length of the raw data must be smaller or equal to 10 Ki.
|
|
@@ -227,6 +253,8 @@ class AllocatedDeviceStatusArgs:
|
|
|
227
253
|
def conditions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['_meta.v1.ConditionArgs']]]]:
|
|
228
254
|
"""
|
|
229
255
|
Conditions contains the latest observation of the device's state. If the device has been configured according to the class and claim config references, the `Ready` condition should be True.
|
|
256
|
+
|
|
257
|
+
Must not contain more than 8 entries.
|
|
230
258
|
"""
|
|
231
259
|
return pulumi.get(self, "conditions")
|
|
232
260
|
|
|
@@ -322,6 +350,12 @@ if not MYPY:
|
|
|
322
350
|
"""
|
|
323
351
|
BasicDevice defines one device instance.
|
|
324
352
|
"""
|
|
353
|
+
all_nodes: NotRequired[pulumi.Input[builtins.bool]]
|
|
354
|
+
"""
|
|
355
|
+
AllNodes indicates that all nodes have access to the device.
|
|
356
|
+
|
|
357
|
+
Must only be set if Spec.PerDeviceNodeSelection is set to true. At most one of NodeName, NodeSelector and AllNodes can be set.
|
|
358
|
+
"""
|
|
325
359
|
attributes: NotRequired[pulumi.Input[Mapping[str, pulumi.Input['DeviceAttributeArgsDict']]]]
|
|
326
360
|
"""
|
|
327
361
|
Attributes defines the set of attributes for this device. The name of each attribute must be unique in that set.
|
|
@@ -334,27 +368,107 @@ if not MYPY:
|
|
|
334
368
|
|
|
335
369
|
The maximum number of attributes and capacities combined is 32.
|
|
336
370
|
"""
|
|
371
|
+
consumes_counters: NotRequired[pulumi.Input[Sequence[pulumi.Input['DeviceCounterConsumptionPatchArgsDict']]]]
|
|
372
|
+
"""
|
|
373
|
+
ConsumesCounters defines a list of references to sharedCounters and the set of counters that the device will consume from those counter sets.
|
|
374
|
+
|
|
375
|
+
There can only be a single entry per counterSet.
|
|
376
|
+
|
|
377
|
+
The total number of device counter consumption entries must be <= 32. In addition, the total number in the entire ResourceSlice must be <= 1024 (for example, 64 devices with 16 counters each).
|
|
378
|
+
"""
|
|
379
|
+
node_name: NotRequired[pulumi.Input[builtins.str]]
|
|
380
|
+
"""
|
|
381
|
+
NodeName identifies the node where the device is available.
|
|
382
|
+
|
|
383
|
+
Must only be set if Spec.PerDeviceNodeSelection is set to true. At most one of NodeName, NodeSelector and AllNodes can be set.
|
|
384
|
+
"""
|
|
385
|
+
node_selector: NotRequired[pulumi.Input['_core.v1.NodeSelectorPatchArgsDict']]
|
|
386
|
+
"""
|
|
387
|
+
NodeSelector defines the nodes where the device is available.
|
|
388
|
+
|
|
389
|
+
Must use exactly one term.
|
|
390
|
+
|
|
391
|
+
Must only be set if Spec.PerDeviceNodeSelection is set to true. At most one of NodeName, NodeSelector and AllNodes can be set.
|
|
392
|
+
"""
|
|
393
|
+
taints: NotRequired[pulumi.Input[Sequence[pulumi.Input['DeviceTaintPatchArgsDict']]]]
|
|
394
|
+
"""
|
|
395
|
+
If specified, these are the driver-defined taints.
|
|
396
|
+
|
|
397
|
+
The maximum number of taints is 4.
|
|
398
|
+
|
|
399
|
+
This is an alpha field and requires enabling the DRADeviceTaints feature gate.
|
|
400
|
+
"""
|
|
337
401
|
elif False:
|
|
338
402
|
BasicDevicePatchArgsDict: TypeAlias = Mapping[str, Any]
|
|
339
403
|
|
|
340
404
|
@pulumi.input_type
|
|
341
405
|
class BasicDevicePatchArgs:
|
|
342
406
|
def __init__(__self__, *,
|
|
407
|
+
all_nodes: Optional[pulumi.Input[builtins.bool]] = None,
|
|
343
408
|
attributes: Optional[pulumi.Input[Mapping[str, pulumi.Input['DeviceAttributeArgs']]]] = None,
|
|
344
|
-
capacity: Optional[pulumi.Input[Mapping[str, pulumi.Input['DeviceCapacityArgs']]]] = None
|
|
409
|
+
capacity: Optional[pulumi.Input[Mapping[str, pulumi.Input['DeviceCapacityArgs']]]] = None,
|
|
410
|
+
consumes_counters: Optional[pulumi.Input[Sequence[pulumi.Input['DeviceCounterConsumptionPatchArgs']]]] = None,
|
|
411
|
+
node_name: Optional[pulumi.Input[builtins.str]] = None,
|
|
412
|
+
node_selector: Optional[pulumi.Input['_core.v1.NodeSelectorPatchArgs']] = None,
|
|
413
|
+
taints: Optional[pulumi.Input[Sequence[pulumi.Input['DeviceTaintPatchArgs']]]] = None):
|
|
345
414
|
"""
|
|
346
415
|
BasicDevice defines one device instance.
|
|
416
|
+
:param pulumi.Input[builtins.bool] all_nodes: AllNodes indicates that all nodes have access to the device.
|
|
417
|
+
|
|
418
|
+
Must only be set if Spec.PerDeviceNodeSelection is set to true. At most one of NodeName, NodeSelector and AllNodes can be set.
|
|
347
419
|
:param pulumi.Input[Mapping[str, pulumi.Input['DeviceAttributeArgs']]] attributes: Attributes defines the set of attributes for this device. The name of each attribute must be unique in that set.
|
|
348
420
|
|
|
349
421
|
The maximum number of attributes and capacities combined is 32.
|
|
350
422
|
:param pulumi.Input[Mapping[str, pulumi.Input['DeviceCapacityArgs']]] capacity: Capacity defines the set of capacities for this device. The name of each capacity must be unique in that set.
|
|
351
423
|
|
|
352
424
|
The maximum number of attributes and capacities combined is 32.
|
|
425
|
+
:param pulumi.Input[Sequence[pulumi.Input['DeviceCounterConsumptionPatchArgs']]] consumes_counters: ConsumesCounters defines a list of references to sharedCounters and the set of counters that the device will consume from those counter sets.
|
|
426
|
+
|
|
427
|
+
There can only be a single entry per counterSet.
|
|
428
|
+
|
|
429
|
+
The total number of device counter consumption entries must be <= 32. In addition, the total number in the entire ResourceSlice must be <= 1024 (for example, 64 devices with 16 counters each).
|
|
430
|
+
:param pulumi.Input[builtins.str] node_name: NodeName identifies the node where the device is available.
|
|
431
|
+
|
|
432
|
+
Must only be set if Spec.PerDeviceNodeSelection is set to true. At most one of NodeName, NodeSelector and AllNodes can be set.
|
|
433
|
+
:param pulumi.Input['_core.v1.NodeSelectorPatchArgs'] node_selector: NodeSelector defines the nodes where the device is available.
|
|
434
|
+
|
|
435
|
+
Must use exactly one term.
|
|
436
|
+
|
|
437
|
+
Must only be set if Spec.PerDeviceNodeSelection is set to true. At most one of NodeName, NodeSelector and AllNodes can be set.
|
|
438
|
+
:param pulumi.Input[Sequence[pulumi.Input['DeviceTaintPatchArgs']]] taints: If specified, these are the driver-defined taints.
|
|
439
|
+
|
|
440
|
+
The maximum number of taints is 4.
|
|
441
|
+
|
|
442
|
+
This is an alpha field and requires enabling the DRADeviceTaints feature gate.
|
|
353
443
|
"""
|
|
444
|
+
if all_nodes is not None:
|
|
445
|
+
pulumi.set(__self__, "all_nodes", all_nodes)
|
|
354
446
|
if attributes is not None:
|
|
355
447
|
pulumi.set(__self__, "attributes", attributes)
|
|
356
448
|
if capacity is not None:
|
|
357
449
|
pulumi.set(__self__, "capacity", capacity)
|
|
450
|
+
if consumes_counters is not None:
|
|
451
|
+
pulumi.set(__self__, "consumes_counters", consumes_counters)
|
|
452
|
+
if node_name is not None:
|
|
453
|
+
pulumi.set(__self__, "node_name", node_name)
|
|
454
|
+
if node_selector is not None:
|
|
455
|
+
pulumi.set(__self__, "node_selector", node_selector)
|
|
456
|
+
if taints is not None:
|
|
457
|
+
pulumi.set(__self__, "taints", taints)
|
|
458
|
+
|
|
459
|
+
@property
|
|
460
|
+
@pulumi.getter(name="allNodes")
|
|
461
|
+
def all_nodes(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
462
|
+
"""
|
|
463
|
+
AllNodes indicates that all nodes have access to the device.
|
|
464
|
+
|
|
465
|
+
Must only be set if Spec.PerDeviceNodeSelection is set to true. At most one of NodeName, NodeSelector and AllNodes can be set.
|
|
466
|
+
"""
|
|
467
|
+
return pulumi.get(self, "all_nodes")
|
|
468
|
+
|
|
469
|
+
@all_nodes.setter
|
|
470
|
+
def all_nodes(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
471
|
+
pulumi.set(self, "all_nodes", value)
|
|
358
472
|
|
|
359
473
|
@property
|
|
360
474
|
@pulumi.getter
|
|
@@ -384,12 +498,80 @@ class BasicDevicePatchArgs:
|
|
|
384
498
|
def capacity(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input['DeviceCapacityArgs']]]]):
|
|
385
499
|
pulumi.set(self, "capacity", value)
|
|
386
500
|
|
|
501
|
+
@property
|
|
502
|
+
@pulumi.getter(name="consumesCounters")
|
|
503
|
+
def consumes_counters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DeviceCounterConsumptionPatchArgs']]]]:
|
|
504
|
+
"""
|
|
505
|
+
ConsumesCounters defines a list of references to sharedCounters and the set of counters that the device will consume from those counter sets.
|
|
506
|
+
|
|
507
|
+
There can only be a single entry per counterSet.
|
|
508
|
+
|
|
509
|
+
The total number of device counter consumption entries must be <= 32. In addition, the total number in the entire ResourceSlice must be <= 1024 (for example, 64 devices with 16 counters each).
|
|
510
|
+
"""
|
|
511
|
+
return pulumi.get(self, "consumes_counters")
|
|
512
|
+
|
|
513
|
+
@consumes_counters.setter
|
|
514
|
+
def consumes_counters(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DeviceCounterConsumptionPatchArgs']]]]):
|
|
515
|
+
pulumi.set(self, "consumes_counters", value)
|
|
516
|
+
|
|
517
|
+
@property
|
|
518
|
+
@pulumi.getter(name="nodeName")
|
|
519
|
+
def node_name(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
520
|
+
"""
|
|
521
|
+
NodeName identifies the node where the device is available.
|
|
522
|
+
|
|
523
|
+
Must only be set if Spec.PerDeviceNodeSelection is set to true. At most one of NodeName, NodeSelector and AllNodes can be set.
|
|
524
|
+
"""
|
|
525
|
+
return pulumi.get(self, "node_name")
|
|
526
|
+
|
|
527
|
+
@node_name.setter
|
|
528
|
+
def node_name(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
529
|
+
pulumi.set(self, "node_name", value)
|
|
530
|
+
|
|
531
|
+
@property
|
|
532
|
+
@pulumi.getter(name="nodeSelector")
|
|
533
|
+
def node_selector(self) -> Optional[pulumi.Input['_core.v1.NodeSelectorPatchArgs']]:
|
|
534
|
+
"""
|
|
535
|
+
NodeSelector defines the nodes where the device is available.
|
|
536
|
+
|
|
537
|
+
Must use exactly one term.
|
|
538
|
+
|
|
539
|
+
Must only be set if Spec.PerDeviceNodeSelection is set to true. At most one of NodeName, NodeSelector and AllNodes can be set.
|
|
540
|
+
"""
|
|
541
|
+
return pulumi.get(self, "node_selector")
|
|
542
|
+
|
|
543
|
+
@node_selector.setter
|
|
544
|
+
def node_selector(self, value: Optional[pulumi.Input['_core.v1.NodeSelectorPatchArgs']]):
|
|
545
|
+
pulumi.set(self, "node_selector", value)
|
|
546
|
+
|
|
547
|
+
@property
|
|
548
|
+
@pulumi.getter
|
|
549
|
+
def taints(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DeviceTaintPatchArgs']]]]:
|
|
550
|
+
"""
|
|
551
|
+
If specified, these are the driver-defined taints.
|
|
552
|
+
|
|
553
|
+
The maximum number of taints is 4.
|
|
554
|
+
|
|
555
|
+
This is an alpha field and requires enabling the DRADeviceTaints feature gate.
|
|
556
|
+
"""
|
|
557
|
+
return pulumi.get(self, "taints")
|
|
558
|
+
|
|
559
|
+
@taints.setter
|
|
560
|
+
def taints(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DeviceTaintPatchArgs']]]]):
|
|
561
|
+
pulumi.set(self, "taints", value)
|
|
562
|
+
|
|
387
563
|
|
|
388
564
|
if not MYPY:
|
|
389
565
|
class BasicDeviceArgsDict(TypedDict):
|
|
390
566
|
"""
|
|
391
567
|
BasicDevice defines one device instance.
|
|
392
568
|
"""
|
|
569
|
+
all_nodes: NotRequired[pulumi.Input[builtins.bool]]
|
|
570
|
+
"""
|
|
571
|
+
AllNodes indicates that all nodes have access to the device.
|
|
572
|
+
|
|
573
|
+
Must only be set if Spec.PerDeviceNodeSelection is set to true. At most one of NodeName, NodeSelector and AllNodes can be set.
|
|
574
|
+
"""
|
|
393
575
|
attributes: NotRequired[pulumi.Input[Mapping[str, pulumi.Input['DeviceAttributeArgsDict']]]]
|
|
394
576
|
"""
|
|
395
577
|
Attributes defines the set of attributes for this device. The name of each attribute must be unique in that set.
|
|
@@ -402,27 +584,107 @@ if not MYPY:
|
|
|
402
584
|
|
|
403
585
|
The maximum number of attributes and capacities combined is 32.
|
|
404
586
|
"""
|
|
587
|
+
consumes_counters: NotRequired[pulumi.Input[Sequence[pulumi.Input['DeviceCounterConsumptionArgsDict']]]]
|
|
588
|
+
"""
|
|
589
|
+
ConsumesCounters defines a list of references to sharedCounters and the set of counters that the device will consume from those counter sets.
|
|
590
|
+
|
|
591
|
+
There can only be a single entry per counterSet.
|
|
592
|
+
|
|
593
|
+
The total number of device counter consumption entries must be <= 32. In addition, the total number in the entire ResourceSlice must be <= 1024 (for example, 64 devices with 16 counters each).
|
|
594
|
+
"""
|
|
595
|
+
node_name: NotRequired[pulumi.Input[builtins.str]]
|
|
596
|
+
"""
|
|
597
|
+
NodeName identifies the node where the device is available.
|
|
598
|
+
|
|
599
|
+
Must only be set if Spec.PerDeviceNodeSelection is set to true. At most one of NodeName, NodeSelector and AllNodes can be set.
|
|
600
|
+
"""
|
|
601
|
+
node_selector: NotRequired[pulumi.Input['_core.v1.NodeSelectorArgsDict']]
|
|
602
|
+
"""
|
|
603
|
+
NodeSelector defines the nodes where the device is available.
|
|
604
|
+
|
|
605
|
+
Must use exactly one term.
|
|
606
|
+
|
|
607
|
+
Must only be set if Spec.PerDeviceNodeSelection is set to true. At most one of NodeName, NodeSelector and AllNodes can be set.
|
|
608
|
+
"""
|
|
609
|
+
taints: NotRequired[pulumi.Input[Sequence[pulumi.Input['DeviceTaintArgsDict']]]]
|
|
610
|
+
"""
|
|
611
|
+
If specified, these are the driver-defined taints.
|
|
612
|
+
|
|
613
|
+
The maximum number of taints is 4.
|
|
614
|
+
|
|
615
|
+
This is an alpha field and requires enabling the DRADeviceTaints feature gate.
|
|
616
|
+
"""
|
|
405
617
|
elif False:
|
|
406
618
|
BasicDeviceArgsDict: TypeAlias = Mapping[str, Any]
|
|
407
619
|
|
|
408
620
|
@pulumi.input_type
|
|
409
621
|
class BasicDeviceArgs:
|
|
410
622
|
def __init__(__self__, *,
|
|
623
|
+
all_nodes: Optional[pulumi.Input[builtins.bool]] = None,
|
|
411
624
|
attributes: Optional[pulumi.Input[Mapping[str, pulumi.Input['DeviceAttributeArgs']]]] = None,
|
|
412
|
-
capacity: Optional[pulumi.Input[Mapping[str, pulumi.Input['DeviceCapacityArgs']]]] = None
|
|
625
|
+
capacity: Optional[pulumi.Input[Mapping[str, pulumi.Input['DeviceCapacityArgs']]]] = None,
|
|
626
|
+
consumes_counters: Optional[pulumi.Input[Sequence[pulumi.Input['DeviceCounterConsumptionArgs']]]] = None,
|
|
627
|
+
node_name: Optional[pulumi.Input[builtins.str]] = None,
|
|
628
|
+
node_selector: Optional[pulumi.Input['_core.v1.NodeSelectorArgs']] = None,
|
|
629
|
+
taints: Optional[pulumi.Input[Sequence[pulumi.Input['DeviceTaintArgs']]]] = None):
|
|
413
630
|
"""
|
|
414
631
|
BasicDevice defines one device instance.
|
|
632
|
+
:param pulumi.Input[builtins.bool] all_nodes: AllNodes indicates that all nodes have access to the device.
|
|
633
|
+
|
|
634
|
+
Must only be set if Spec.PerDeviceNodeSelection is set to true. At most one of NodeName, NodeSelector and AllNodes can be set.
|
|
415
635
|
:param pulumi.Input[Mapping[str, pulumi.Input['DeviceAttributeArgs']]] attributes: Attributes defines the set of attributes for this device. The name of each attribute must be unique in that set.
|
|
416
636
|
|
|
417
637
|
The maximum number of attributes and capacities combined is 32.
|
|
418
638
|
:param pulumi.Input[Mapping[str, pulumi.Input['DeviceCapacityArgs']]] capacity: Capacity defines the set of capacities for this device. The name of each capacity must be unique in that set.
|
|
419
639
|
|
|
420
640
|
The maximum number of attributes and capacities combined is 32.
|
|
641
|
+
:param pulumi.Input[Sequence[pulumi.Input['DeviceCounterConsumptionArgs']]] consumes_counters: ConsumesCounters defines a list of references to sharedCounters and the set of counters that the device will consume from those counter sets.
|
|
642
|
+
|
|
643
|
+
There can only be a single entry per counterSet.
|
|
644
|
+
|
|
645
|
+
The total number of device counter consumption entries must be <= 32. In addition, the total number in the entire ResourceSlice must be <= 1024 (for example, 64 devices with 16 counters each).
|
|
646
|
+
:param pulumi.Input[builtins.str] node_name: NodeName identifies the node where the device is available.
|
|
647
|
+
|
|
648
|
+
Must only be set if Spec.PerDeviceNodeSelection is set to true. At most one of NodeName, NodeSelector and AllNodes can be set.
|
|
649
|
+
:param pulumi.Input['_core.v1.NodeSelectorArgs'] node_selector: NodeSelector defines the nodes where the device is available.
|
|
650
|
+
|
|
651
|
+
Must use exactly one term.
|
|
652
|
+
|
|
653
|
+
Must only be set if Spec.PerDeviceNodeSelection is set to true. At most one of NodeName, NodeSelector and AllNodes can be set.
|
|
654
|
+
:param pulumi.Input[Sequence[pulumi.Input['DeviceTaintArgs']]] taints: If specified, these are the driver-defined taints.
|
|
655
|
+
|
|
656
|
+
The maximum number of taints is 4.
|
|
657
|
+
|
|
658
|
+
This is an alpha field and requires enabling the DRADeviceTaints feature gate.
|
|
421
659
|
"""
|
|
660
|
+
if all_nodes is not None:
|
|
661
|
+
pulumi.set(__self__, "all_nodes", all_nodes)
|
|
422
662
|
if attributes is not None:
|
|
423
663
|
pulumi.set(__self__, "attributes", attributes)
|
|
424
664
|
if capacity is not None:
|
|
425
665
|
pulumi.set(__self__, "capacity", capacity)
|
|
666
|
+
if consumes_counters is not None:
|
|
667
|
+
pulumi.set(__self__, "consumes_counters", consumes_counters)
|
|
668
|
+
if node_name is not None:
|
|
669
|
+
pulumi.set(__self__, "node_name", node_name)
|
|
670
|
+
if node_selector is not None:
|
|
671
|
+
pulumi.set(__self__, "node_selector", node_selector)
|
|
672
|
+
if taints is not None:
|
|
673
|
+
pulumi.set(__self__, "taints", taints)
|
|
674
|
+
|
|
675
|
+
@property
|
|
676
|
+
@pulumi.getter(name="allNodes")
|
|
677
|
+
def all_nodes(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
678
|
+
"""
|
|
679
|
+
AllNodes indicates that all nodes have access to the device.
|
|
680
|
+
|
|
681
|
+
Must only be set if Spec.PerDeviceNodeSelection is set to true. At most one of NodeName, NodeSelector and AllNodes can be set.
|
|
682
|
+
"""
|
|
683
|
+
return pulumi.get(self, "all_nodes")
|
|
684
|
+
|
|
685
|
+
@all_nodes.setter
|
|
686
|
+
def all_nodes(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
687
|
+
pulumi.set(self, "all_nodes", value)
|
|
426
688
|
|
|
427
689
|
@property
|
|
428
690
|
@pulumi.getter
|
|
@@ -452,6 +714,68 @@ class BasicDeviceArgs:
|
|
|
452
714
|
def capacity(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input['DeviceCapacityArgs']]]]):
|
|
453
715
|
pulumi.set(self, "capacity", value)
|
|
454
716
|
|
|
717
|
+
@property
|
|
718
|
+
@pulumi.getter(name="consumesCounters")
|
|
719
|
+
def consumes_counters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DeviceCounterConsumptionArgs']]]]:
|
|
720
|
+
"""
|
|
721
|
+
ConsumesCounters defines a list of references to sharedCounters and the set of counters that the device will consume from those counter sets.
|
|
722
|
+
|
|
723
|
+
There can only be a single entry per counterSet.
|
|
724
|
+
|
|
725
|
+
The total number of device counter consumption entries must be <= 32. In addition, the total number in the entire ResourceSlice must be <= 1024 (for example, 64 devices with 16 counters each).
|
|
726
|
+
"""
|
|
727
|
+
return pulumi.get(self, "consumes_counters")
|
|
728
|
+
|
|
729
|
+
@consumes_counters.setter
|
|
730
|
+
def consumes_counters(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DeviceCounterConsumptionArgs']]]]):
|
|
731
|
+
pulumi.set(self, "consumes_counters", value)
|
|
732
|
+
|
|
733
|
+
@property
|
|
734
|
+
@pulumi.getter(name="nodeName")
|
|
735
|
+
def node_name(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
736
|
+
"""
|
|
737
|
+
NodeName identifies the node where the device is available.
|
|
738
|
+
|
|
739
|
+
Must only be set if Spec.PerDeviceNodeSelection is set to true. At most one of NodeName, NodeSelector and AllNodes can be set.
|
|
740
|
+
"""
|
|
741
|
+
return pulumi.get(self, "node_name")
|
|
742
|
+
|
|
743
|
+
@node_name.setter
|
|
744
|
+
def node_name(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
745
|
+
pulumi.set(self, "node_name", value)
|
|
746
|
+
|
|
747
|
+
@property
|
|
748
|
+
@pulumi.getter(name="nodeSelector")
|
|
749
|
+
def node_selector(self) -> Optional[pulumi.Input['_core.v1.NodeSelectorArgs']]:
|
|
750
|
+
"""
|
|
751
|
+
NodeSelector defines the nodes where the device is available.
|
|
752
|
+
|
|
753
|
+
Must use exactly one term.
|
|
754
|
+
|
|
755
|
+
Must only be set if Spec.PerDeviceNodeSelection is set to true. At most one of NodeName, NodeSelector and AllNodes can be set.
|
|
756
|
+
"""
|
|
757
|
+
return pulumi.get(self, "node_selector")
|
|
758
|
+
|
|
759
|
+
@node_selector.setter
|
|
760
|
+
def node_selector(self, value: Optional[pulumi.Input['_core.v1.NodeSelectorArgs']]):
|
|
761
|
+
pulumi.set(self, "node_selector", value)
|
|
762
|
+
|
|
763
|
+
@property
|
|
764
|
+
@pulumi.getter
|
|
765
|
+
def taints(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DeviceTaintArgs']]]]:
|
|
766
|
+
"""
|
|
767
|
+
If specified, these are the driver-defined taints.
|
|
768
|
+
|
|
769
|
+
The maximum number of taints is 4.
|
|
770
|
+
|
|
771
|
+
This is an alpha field and requires enabling the DRADeviceTaints feature gate.
|
|
772
|
+
"""
|
|
773
|
+
return pulumi.get(self, "taints")
|
|
774
|
+
|
|
775
|
+
@taints.setter
|
|
776
|
+
def taints(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DeviceTaintArgs']]]]):
|
|
777
|
+
pulumi.set(self, "taints", value)
|
|
778
|
+
|
|
455
779
|
|
|
456
780
|
if not MYPY:
|
|
457
781
|
class CELDeviceSelectorPatchArgsDict(TypedDict):
|
|
@@ -693,92 +1017,263 @@ class CELDeviceSelectorArgs:
|
|
|
693
1017
|
|
|
694
1018
|
|
|
695
1019
|
if not MYPY:
|
|
696
|
-
class
|
|
697
|
-
"""
|
|
698
|
-
DeviceAllocationConfiguration gets embedded in an AllocationResult.
|
|
699
|
-
"""
|
|
700
|
-
source: pulumi.Input[builtins.str]
|
|
1020
|
+
class CounterSetPatchArgsDict(TypedDict):
|
|
701
1021
|
"""
|
|
702
|
-
|
|
1022
|
+
CounterSet defines a named set of counters that are available to be used by devices defined in the ResourceSlice.
|
|
1023
|
+
|
|
1024
|
+
The counters are not allocatable by themselves, but can be referenced by devices. When a device is allocated, the portion of counters it uses will no longer be available for use by other devices.
|
|
703
1025
|
"""
|
|
704
|
-
|
|
1026
|
+
counters: NotRequired[pulumi.Input[Mapping[str, pulumi.Input['CounterArgsDict']]]]
|
|
705
1027
|
"""
|
|
706
|
-
|
|
1028
|
+
Counters defines the set of counters for this CounterSet The name of each counter must be unique in that set and must be a DNS label.
|
|
1029
|
+
|
|
1030
|
+
The maximum number of counters is 32.
|
|
707
1031
|
"""
|
|
708
|
-
|
|
1032
|
+
name: NotRequired[pulumi.Input[builtins.str]]
|
|
709
1033
|
"""
|
|
710
|
-
|
|
1034
|
+
Name defines the name of the counter set. It must be a DNS label.
|
|
711
1035
|
"""
|
|
712
1036
|
elif False:
|
|
713
|
-
|
|
1037
|
+
CounterSetPatchArgsDict: TypeAlias = Mapping[str, Any]
|
|
714
1038
|
|
|
715
1039
|
@pulumi.input_type
|
|
716
|
-
class
|
|
1040
|
+
class CounterSetPatchArgs:
|
|
717
1041
|
def __init__(__self__, *,
|
|
718
|
-
|
|
719
|
-
|
|
720
|
-
requests: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None):
|
|
721
|
-
"""
|
|
722
|
-
DeviceAllocationConfiguration gets embedded in an AllocationResult.
|
|
723
|
-
:param pulumi.Input[builtins.str] source: Source records whether the configuration comes from a class and thus is not something that a normal user would have been able to set or from a claim.
|
|
724
|
-
:param pulumi.Input['OpaqueDeviceConfigurationArgs'] opaque: Opaque provides driver-specific configuration parameters.
|
|
725
|
-
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] requests: Requests lists the names of requests where the configuration applies. If empty, its applies to all requests.
|
|
1042
|
+
counters: Optional[pulumi.Input[Mapping[str, pulumi.Input['CounterArgs']]]] = None,
|
|
1043
|
+
name: Optional[pulumi.Input[builtins.str]] = None):
|
|
726
1044
|
"""
|
|
727
|
-
|
|
728
|
-
if opaque is not None:
|
|
729
|
-
pulumi.set(__self__, "opaque", opaque)
|
|
730
|
-
if requests is not None:
|
|
731
|
-
pulumi.set(__self__, "requests", requests)
|
|
1045
|
+
CounterSet defines a named set of counters that are available to be used by devices defined in the ResourceSlice.
|
|
732
1046
|
|
|
733
|
-
|
|
734
|
-
|
|
735
|
-
|
|
736
|
-
|
|
737
|
-
|
|
1047
|
+
The counters are not allocatable by themselves, but can be referenced by devices. When a device is allocated, the portion of counters it uses will no longer be available for use by other devices.
|
|
1048
|
+
:param pulumi.Input[Mapping[str, pulumi.Input['CounterArgs']]] counters: Counters defines the set of counters for this CounterSet The name of each counter must be unique in that set and must be a DNS label.
|
|
1049
|
+
|
|
1050
|
+
The maximum number of counters is 32.
|
|
1051
|
+
:param pulumi.Input[builtins.str] name: Name defines the name of the counter set. It must be a DNS label.
|
|
738
1052
|
"""
|
|
739
|
-
|
|
740
|
-
|
|
741
|
-
|
|
742
|
-
|
|
743
|
-
pulumi.set(self, "source", value)
|
|
1053
|
+
if counters is not None:
|
|
1054
|
+
pulumi.set(__self__, "counters", counters)
|
|
1055
|
+
if name is not None:
|
|
1056
|
+
pulumi.set(__self__, "name", name)
|
|
744
1057
|
|
|
745
1058
|
@property
|
|
746
1059
|
@pulumi.getter
|
|
747
|
-
def
|
|
1060
|
+
def counters(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input['CounterArgs']]]]:
|
|
748
1061
|
"""
|
|
749
|
-
|
|
1062
|
+
Counters defines the set of counters for this CounterSet The name of each counter must be unique in that set and must be a DNS label.
|
|
1063
|
+
|
|
1064
|
+
The maximum number of counters is 32.
|
|
750
1065
|
"""
|
|
751
|
-
return pulumi.get(self, "
|
|
1066
|
+
return pulumi.get(self, "counters")
|
|
752
1067
|
|
|
753
|
-
@
|
|
754
|
-
def
|
|
755
|
-
pulumi.set(self, "
|
|
1068
|
+
@counters.setter
|
|
1069
|
+
def counters(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input['CounterArgs']]]]):
|
|
1070
|
+
pulumi.set(self, "counters", value)
|
|
756
1071
|
|
|
757
1072
|
@property
|
|
758
1073
|
@pulumi.getter
|
|
759
|
-
def
|
|
1074
|
+
def name(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
760
1075
|
"""
|
|
761
|
-
|
|
1076
|
+
Name defines the name of the counter set. It must be a DNS label.
|
|
762
1077
|
"""
|
|
763
|
-
return pulumi.get(self, "
|
|
1078
|
+
return pulumi.get(self, "name")
|
|
764
1079
|
|
|
765
|
-
@
|
|
766
|
-
def
|
|
767
|
-
pulumi.set(self, "
|
|
1080
|
+
@name.setter
|
|
1081
|
+
def name(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
1082
|
+
pulumi.set(self, "name", value)
|
|
768
1083
|
|
|
769
1084
|
|
|
770
1085
|
if not MYPY:
|
|
771
|
-
class
|
|
1086
|
+
class CounterSetArgsDict(TypedDict):
|
|
772
1087
|
"""
|
|
773
|
-
|
|
1088
|
+
CounterSet defines a named set of counters that are available to be used by devices defined in the ResourceSlice.
|
|
1089
|
+
|
|
1090
|
+
The counters are not allocatable by themselves, but can be referenced by devices. When a device is allocated, the portion of counters it uses will no longer be available for use by other devices.
|
|
774
1091
|
"""
|
|
775
|
-
|
|
1092
|
+
counters: pulumi.Input[Mapping[str, pulumi.Input['CounterArgsDict']]]
|
|
776
1093
|
"""
|
|
777
|
-
|
|
1094
|
+
Counters defines the set of counters for this CounterSet The name of each counter must be unique in that set and must be a DNS label.
|
|
778
1095
|
|
|
779
|
-
|
|
1096
|
+
The maximum number of counters is 32.
|
|
780
1097
|
"""
|
|
781
|
-
|
|
1098
|
+
name: pulumi.Input[builtins.str]
|
|
1099
|
+
"""
|
|
1100
|
+
Name defines the name of the counter set. It must be a DNS label.
|
|
1101
|
+
"""
|
|
1102
|
+
elif False:
|
|
1103
|
+
CounterSetArgsDict: TypeAlias = Mapping[str, Any]
|
|
1104
|
+
|
|
1105
|
+
@pulumi.input_type
|
|
1106
|
+
class CounterSetArgs:
|
|
1107
|
+
def __init__(__self__, *,
|
|
1108
|
+
counters: pulumi.Input[Mapping[str, pulumi.Input['CounterArgs']]],
|
|
1109
|
+
name: pulumi.Input[builtins.str]):
|
|
1110
|
+
"""
|
|
1111
|
+
CounterSet defines a named set of counters that are available to be used by devices defined in the ResourceSlice.
|
|
1112
|
+
|
|
1113
|
+
The counters are not allocatable by themselves, but can be referenced by devices. When a device is allocated, the portion of counters it uses will no longer be available for use by other devices.
|
|
1114
|
+
:param pulumi.Input[Mapping[str, pulumi.Input['CounterArgs']]] counters: Counters defines the set of counters for this CounterSet The name of each counter must be unique in that set and must be a DNS label.
|
|
1115
|
+
|
|
1116
|
+
The maximum number of counters is 32.
|
|
1117
|
+
:param pulumi.Input[builtins.str] name: Name defines the name of the counter set. It must be a DNS label.
|
|
1118
|
+
"""
|
|
1119
|
+
pulumi.set(__self__, "counters", counters)
|
|
1120
|
+
pulumi.set(__self__, "name", name)
|
|
1121
|
+
|
|
1122
|
+
@property
|
|
1123
|
+
@pulumi.getter
|
|
1124
|
+
def counters(self) -> pulumi.Input[Mapping[str, pulumi.Input['CounterArgs']]]:
|
|
1125
|
+
"""
|
|
1126
|
+
Counters defines the set of counters for this CounterSet The name of each counter must be unique in that set and must be a DNS label.
|
|
1127
|
+
|
|
1128
|
+
The maximum number of counters is 32.
|
|
1129
|
+
"""
|
|
1130
|
+
return pulumi.get(self, "counters")
|
|
1131
|
+
|
|
1132
|
+
@counters.setter
|
|
1133
|
+
def counters(self, value: pulumi.Input[Mapping[str, pulumi.Input['CounterArgs']]]):
|
|
1134
|
+
pulumi.set(self, "counters", value)
|
|
1135
|
+
|
|
1136
|
+
@property
|
|
1137
|
+
@pulumi.getter
|
|
1138
|
+
def name(self) -> pulumi.Input[builtins.str]:
|
|
1139
|
+
"""
|
|
1140
|
+
Name defines the name of the counter set. It must be a DNS label.
|
|
1141
|
+
"""
|
|
1142
|
+
return pulumi.get(self, "name")
|
|
1143
|
+
|
|
1144
|
+
@name.setter
|
|
1145
|
+
def name(self, value: pulumi.Input[builtins.str]):
|
|
1146
|
+
pulumi.set(self, "name", value)
|
|
1147
|
+
|
|
1148
|
+
|
|
1149
|
+
if not MYPY:
|
|
1150
|
+
class CounterArgsDict(TypedDict):
|
|
1151
|
+
"""
|
|
1152
|
+
Counter describes a quantity associated with a device.
|
|
1153
|
+
"""
|
|
1154
|
+
value: pulumi.Input[builtins.str]
|
|
1155
|
+
"""
|
|
1156
|
+
Value defines how much of a certain device counter is available.
|
|
1157
|
+
"""
|
|
1158
|
+
elif False:
|
|
1159
|
+
CounterArgsDict: TypeAlias = Mapping[str, Any]
|
|
1160
|
+
|
|
1161
|
+
@pulumi.input_type
|
|
1162
|
+
class CounterArgs:
|
|
1163
|
+
def __init__(__self__, *,
|
|
1164
|
+
value: pulumi.Input[builtins.str]):
|
|
1165
|
+
"""
|
|
1166
|
+
Counter describes a quantity associated with a device.
|
|
1167
|
+
:param pulumi.Input[builtins.str] value: Value defines how much of a certain device counter is available.
|
|
1168
|
+
"""
|
|
1169
|
+
pulumi.set(__self__, "value", value)
|
|
1170
|
+
|
|
1171
|
+
@property
|
|
1172
|
+
@pulumi.getter
|
|
1173
|
+
def value(self) -> pulumi.Input[builtins.str]:
|
|
1174
|
+
"""
|
|
1175
|
+
Value defines how much of a certain device counter is available.
|
|
1176
|
+
"""
|
|
1177
|
+
return pulumi.get(self, "value")
|
|
1178
|
+
|
|
1179
|
+
@value.setter
|
|
1180
|
+
def value(self, value: pulumi.Input[builtins.str]):
|
|
1181
|
+
pulumi.set(self, "value", value)
|
|
1182
|
+
|
|
1183
|
+
|
|
1184
|
+
if not MYPY:
|
|
1185
|
+
class DeviceAllocationConfigurationArgsDict(TypedDict):
|
|
1186
|
+
"""
|
|
1187
|
+
DeviceAllocationConfiguration gets embedded in an AllocationResult.
|
|
1188
|
+
"""
|
|
1189
|
+
source: pulumi.Input[builtins.str]
|
|
1190
|
+
"""
|
|
1191
|
+
Source records whether the configuration comes from a class and thus is not something that a normal user would have been able to set or from a claim.
|
|
1192
|
+
"""
|
|
1193
|
+
opaque: NotRequired[pulumi.Input['OpaqueDeviceConfigurationArgsDict']]
|
|
1194
|
+
"""
|
|
1195
|
+
Opaque provides driver-specific configuration parameters.
|
|
1196
|
+
"""
|
|
1197
|
+
requests: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
|
|
1198
|
+
"""
|
|
1199
|
+
Requests lists the names of requests where the configuration applies. If empty, its applies to all requests.
|
|
1200
|
+
|
|
1201
|
+
References to subrequests must include the name of the main request and may include the subrequest using the format <main request>[/<subrequest>]. If just the main request is given, the configuration applies to all subrequests.
|
|
1202
|
+
"""
|
|
1203
|
+
elif False:
|
|
1204
|
+
DeviceAllocationConfigurationArgsDict: TypeAlias = Mapping[str, Any]
|
|
1205
|
+
|
|
1206
|
+
@pulumi.input_type
|
|
1207
|
+
class DeviceAllocationConfigurationArgs:
|
|
1208
|
+
def __init__(__self__, *,
|
|
1209
|
+
source: pulumi.Input[builtins.str],
|
|
1210
|
+
opaque: Optional[pulumi.Input['OpaqueDeviceConfigurationArgs']] = None,
|
|
1211
|
+
requests: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None):
|
|
1212
|
+
"""
|
|
1213
|
+
DeviceAllocationConfiguration gets embedded in an AllocationResult.
|
|
1214
|
+
:param pulumi.Input[builtins.str] source: Source records whether the configuration comes from a class and thus is not something that a normal user would have been able to set or from a claim.
|
|
1215
|
+
:param pulumi.Input['OpaqueDeviceConfigurationArgs'] opaque: Opaque provides driver-specific configuration parameters.
|
|
1216
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] requests: Requests lists the names of requests where the configuration applies. If empty, its applies to all requests.
|
|
1217
|
+
|
|
1218
|
+
References to subrequests must include the name of the main request and may include the subrequest using the format <main request>[/<subrequest>]. If just the main request is given, the configuration applies to all subrequests.
|
|
1219
|
+
"""
|
|
1220
|
+
pulumi.set(__self__, "source", source)
|
|
1221
|
+
if opaque is not None:
|
|
1222
|
+
pulumi.set(__self__, "opaque", opaque)
|
|
1223
|
+
if requests is not None:
|
|
1224
|
+
pulumi.set(__self__, "requests", requests)
|
|
1225
|
+
|
|
1226
|
+
@property
|
|
1227
|
+
@pulumi.getter
|
|
1228
|
+
def source(self) -> pulumi.Input[builtins.str]:
|
|
1229
|
+
"""
|
|
1230
|
+
Source records whether the configuration comes from a class and thus is not something that a normal user would have been able to set or from a claim.
|
|
1231
|
+
"""
|
|
1232
|
+
return pulumi.get(self, "source")
|
|
1233
|
+
|
|
1234
|
+
@source.setter
|
|
1235
|
+
def source(self, value: pulumi.Input[builtins.str]):
|
|
1236
|
+
pulumi.set(self, "source", value)
|
|
1237
|
+
|
|
1238
|
+
@property
|
|
1239
|
+
@pulumi.getter
|
|
1240
|
+
def opaque(self) -> Optional[pulumi.Input['OpaqueDeviceConfigurationArgs']]:
|
|
1241
|
+
"""
|
|
1242
|
+
Opaque provides driver-specific configuration parameters.
|
|
1243
|
+
"""
|
|
1244
|
+
return pulumi.get(self, "opaque")
|
|
1245
|
+
|
|
1246
|
+
@opaque.setter
|
|
1247
|
+
def opaque(self, value: Optional[pulumi.Input['OpaqueDeviceConfigurationArgs']]):
|
|
1248
|
+
pulumi.set(self, "opaque", value)
|
|
1249
|
+
|
|
1250
|
+
@property
|
|
1251
|
+
@pulumi.getter
|
|
1252
|
+
def requests(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
1253
|
+
"""
|
|
1254
|
+
Requests lists the names of requests where the configuration applies. If empty, its applies to all requests.
|
|
1255
|
+
|
|
1256
|
+
References to subrequests must include the name of the main request and may include the subrequest using the format <main request>[/<subrequest>]. If just the main request is given, the configuration applies to all subrequests.
|
|
1257
|
+
"""
|
|
1258
|
+
return pulumi.get(self, "requests")
|
|
1259
|
+
|
|
1260
|
+
@requests.setter
|
|
1261
|
+
def requests(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
|
|
1262
|
+
pulumi.set(self, "requests", value)
|
|
1263
|
+
|
|
1264
|
+
|
|
1265
|
+
if not MYPY:
|
|
1266
|
+
class DeviceAllocationResultArgsDict(TypedDict):
|
|
1267
|
+
"""
|
|
1268
|
+
DeviceAllocationResult is the result of allocating devices.
|
|
1269
|
+
"""
|
|
1270
|
+
config: NotRequired[pulumi.Input[Sequence[pulumi.Input['DeviceAllocationConfigurationArgsDict']]]]
|
|
1271
|
+
"""
|
|
1272
|
+
This field is a combination of all the claim and class configuration parameters. Drivers can distinguish between those based on a flag.
|
|
1273
|
+
|
|
1274
|
+
This includes configuration parameters for drivers which have no allocated devices in the result because it is up to the drivers which configuration parameters they support. They can silently ignore unknown configuration parameters.
|
|
1275
|
+
"""
|
|
1276
|
+
results: NotRequired[pulumi.Input[Sequence[pulumi.Input['DeviceRequestAllocationResultArgsDict']]]]
|
|
782
1277
|
"""
|
|
783
1278
|
Results lists all allocated devices.
|
|
784
1279
|
"""
|
|
@@ -972,6 +1467,8 @@ if not MYPY:
|
|
|
972
1467
|
requests: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
|
|
973
1468
|
"""
|
|
974
1469
|
Requests lists the names of requests where the configuration applies. If empty, it applies to all requests.
|
|
1470
|
+
|
|
1471
|
+
References to subrequests must include the name of the main request and may include the subrequest using the format <main request>[/<subrequest>]. If just the main request is given, the configuration applies to all subrequests.
|
|
975
1472
|
"""
|
|
976
1473
|
elif False:
|
|
977
1474
|
DeviceClaimConfigurationPatchArgsDict: TypeAlias = Mapping[str, Any]
|
|
@@ -985,6 +1482,8 @@ class DeviceClaimConfigurationPatchArgs:
|
|
|
985
1482
|
DeviceClaimConfiguration is used for configuration parameters in DeviceClaim.
|
|
986
1483
|
:param pulumi.Input['OpaqueDeviceConfigurationPatchArgs'] opaque: Opaque provides driver-specific configuration parameters.
|
|
987
1484
|
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] requests: Requests lists the names of requests where the configuration applies. If empty, it applies to all requests.
|
|
1485
|
+
|
|
1486
|
+
References to subrequests must include the name of the main request and may include the subrequest using the format <main request>[/<subrequest>]. If just the main request is given, the configuration applies to all subrequests.
|
|
988
1487
|
"""
|
|
989
1488
|
if opaque is not None:
|
|
990
1489
|
pulumi.set(__self__, "opaque", opaque)
|
|
@@ -1008,6 +1507,8 @@ class DeviceClaimConfigurationPatchArgs:
|
|
|
1008
1507
|
def requests(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
1009
1508
|
"""
|
|
1010
1509
|
Requests lists the names of requests where the configuration applies. If empty, it applies to all requests.
|
|
1510
|
+
|
|
1511
|
+
References to subrequests must include the name of the main request and may include the subrequest using the format <main request>[/<subrequest>]. If just the main request is given, the configuration applies to all subrequests.
|
|
1011
1512
|
"""
|
|
1012
1513
|
return pulumi.get(self, "requests")
|
|
1013
1514
|
|
|
@@ -1028,6 +1529,8 @@ if not MYPY:
|
|
|
1028
1529
|
requests: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
|
|
1029
1530
|
"""
|
|
1030
1531
|
Requests lists the names of requests where the configuration applies. If empty, it applies to all requests.
|
|
1532
|
+
|
|
1533
|
+
References to subrequests must include the name of the main request and may include the subrequest using the format <main request>[/<subrequest>]. If just the main request is given, the configuration applies to all subrequests.
|
|
1031
1534
|
"""
|
|
1032
1535
|
elif False:
|
|
1033
1536
|
DeviceClaimConfigurationArgsDict: TypeAlias = Mapping[str, Any]
|
|
@@ -1041,6 +1544,8 @@ class DeviceClaimConfigurationArgs:
|
|
|
1041
1544
|
DeviceClaimConfiguration is used for configuration parameters in DeviceClaim.
|
|
1042
1545
|
:param pulumi.Input['OpaqueDeviceConfigurationArgs'] opaque: Opaque provides driver-specific configuration parameters.
|
|
1043
1546
|
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] requests: Requests lists the names of requests where the configuration applies. If empty, it applies to all requests.
|
|
1547
|
+
|
|
1548
|
+
References to subrequests must include the name of the main request and may include the subrequest using the format <main request>[/<subrequest>]. If just the main request is given, the configuration applies to all subrequests.
|
|
1044
1549
|
"""
|
|
1045
1550
|
if opaque is not None:
|
|
1046
1551
|
pulumi.set(__self__, "opaque", opaque)
|
|
@@ -1064,6 +1569,8 @@ class DeviceClaimConfigurationArgs:
|
|
|
1064
1569
|
def requests(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
1065
1570
|
"""
|
|
1066
1571
|
Requests lists the names of requests where the configuration applies. If empty, it applies to all requests.
|
|
1572
|
+
|
|
1573
|
+
References to subrequests must include the name of the main request and may include the subrequest using the format <main request>[/<subrequest>]. If just the main request is given, the configuration applies to all subrequests.
|
|
1067
1574
|
"""
|
|
1068
1575
|
return pulumi.get(self, "requests")
|
|
1069
1576
|
|
|
@@ -1547,6 +2054,8 @@ if not MYPY:
|
|
|
1547
2054
|
requests: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
|
|
1548
2055
|
"""
|
|
1549
2056
|
Requests is a list of the one or more requests in this claim which must co-satisfy this constraint. If a request is fulfilled by multiple devices, then all of the devices must satisfy the constraint. If this is not specified, this constraint applies to all requests in this claim.
|
|
2057
|
+
|
|
2058
|
+
References to subrequests must include the name of the main request and may include the subrequest using the format <main request>[/<subrequest>]. If just the main request is given, the constraint applies to all subrequests.
|
|
1550
2059
|
"""
|
|
1551
2060
|
elif False:
|
|
1552
2061
|
DeviceConstraintPatchArgsDict: TypeAlias = Mapping[str, Any]
|
|
@@ -1564,6 +2073,8 @@ class DeviceConstraintPatchArgs:
|
|
|
1564
2073
|
|
|
1565
2074
|
Must include the domain qualifier.
|
|
1566
2075
|
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] requests: Requests is a list of the one or more requests in this claim which must co-satisfy this constraint. If a request is fulfilled by multiple devices, then all of the devices must satisfy the constraint. If this is not specified, this constraint applies to all requests in this claim.
|
|
2076
|
+
|
|
2077
|
+
References to subrequests must include the name of the main request and may include the subrequest using the format <main request>[/<subrequest>]. If just the main request is given, the constraint applies to all subrequests.
|
|
1567
2078
|
"""
|
|
1568
2079
|
if match_attribute is not None:
|
|
1569
2080
|
pulumi.set(__self__, "match_attribute", match_attribute)
|
|
@@ -1591,6 +2102,8 @@ class DeviceConstraintPatchArgs:
|
|
|
1591
2102
|
def requests(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
1592
2103
|
"""
|
|
1593
2104
|
Requests is a list of the one or more requests in this claim which must co-satisfy this constraint. If a request is fulfilled by multiple devices, then all of the devices must satisfy the constraint. If this is not specified, this constraint applies to all requests in this claim.
|
|
2105
|
+
|
|
2106
|
+
References to subrequests must include the name of the main request and may include the subrequest using the format <main request>[/<subrequest>]. If just the main request is given, the constraint applies to all subrequests.
|
|
1594
2107
|
"""
|
|
1595
2108
|
return pulumi.get(self, "requests")
|
|
1596
2109
|
|
|
@@ -1615,6 +2128,8 @@ if not MYPY:
|
|
|
1615
2128
|
requests: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
|
|
1616
2129
|
"""
|
|
1617
2130
|
Requests is a list of the one or more requests in this claim which must co-satisfy this constraint. If a request is fulfilled by multiple devices, then all of the devices must satisfy the constraint. If this is not specified, this constraint applies to all requests in this claim.
|
|
2131
|
+
|
|
2132
|
+
References to subrequests must include the name of the main request and may include the subrequest using the format <main request>[/<subrequest>]. If just the main request is given, the constraint applies to all subrequests.
|
|
1618
2133
|
"""
|
|
1619
2134
|
elif False:
|
|
1620
2135
|
DeviceConstraintArgsDict: TypeAlias = Mapping[str, Any]
|
|
@@ -1632,6 +2147,8 @@ class DeviceConstraintArgs:
|
|
|
1632
2147
|
|
|
1633
2148
|
Must include the domain qualifier.
|
|
1634
2149
|
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] requests: Requests is a list of the one or more requests in this claim which must co-satisfy this constraint. If a request is fulfilled by multiple devices, then all of the devices must satisfy the constraint. If this is not specified, this constraint applies to all requests in this claim.
|
|
2150
|
+
|
|
2151
|
+
References to subrequests must include the name of the main request and may include the subrequest using the format <main request>[/<subrequest>]. If just the main request is given, the constraint applies to all subrequests.
|
|
1635
2152
|
"""
|
|
1636
2153
|
if match_attribute is not None:
|
|
1637
2154
|
pulumi.set(__self__, "match_attribute", match_attribute)
|
|
@@ -1659,6 +2176,8 @@ class DeviceConstraintArgs:
|
|
|
1659
2176
|
def requests(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
1660
2177
|
"""
|
|
1661
2178
|
Requests is a list of the one or more requests in this claim which must co-satisfy this constraint. If a request is fulfilled by multiple devices, then all of the devices must satisfy the constraint. If this is not specified, this constraint applies to all requests in this claim.
|
|
2179
|
+
|
|
2180
|
+
References to subrequests must include the name of the main request and may include the subrequest using the format <main request>[/<subrequest>]. If just the main request is given, the constraint applies to all subrequests.
|
|
1662
2181
|
"""
|
|
1663
2182
|
return pulumi.get(self, "requests")
|
|
1664
2183
|
|
|
@@ -1667,6 +2186,128 @@ class DeviceConstraintArgs:
|
|
|
1667
2186
|
pulumi.set(self, "requests", value)
|
|
1668
2187
|
|
|
1669
2188
|
|
|
2189
|
+
if not MYPY:
|
|
2190
|
+
class DeviceCounterConsumptionPatchArgsDict(TypedDict):
|
|
2191
|
+
"""
|
|
2192
|
+
DeviceCounterConsumption defines a set of counters that a device will consume from a CounterSet.
|
|
2193
|
+
"""
|
|
2194
|
+
counter_set: NotRequired[pulumi.Input[builtins.str]]
|
|
2195
|
+
"""
|
|
2196
|
+
CounterSet is the name of the set from which the counters defined will be consumed.
|
|
2197
|
+
"""
|
|
2198
|
+
counters: NotRequired[pulumi.Input[Mapping[str, pulumi.Input['CounterArgsDict']]]]
|
|
2199
|
+
"""
|
|
2200
|
+
Counters defines the counters that will be consumed by the device.
|
|
2201
|
+
|
|
2202
|
+
The maximum number counters in a device is 32. In addition, the maximum number of all counters in all devices is 1024 (for example, 64 devices with 16 counters each).
|
|
2203
|
+
"""
|
|
2204
|
+
elif False:
|
|
2205
|
+
DeviceCounterConsumptionPatchArgsDict: TypeAlias = Mapping[str, Any]
|
|
2206
|
+
|
|
2207
|
+
@pulumi.input_type
|
|
2208
|
+
class DeviceCounterConsumptionPatchArgs:
|
|
2209
|
+
def __init__(__self__, *,
|
|
2210
|
+
counter_set: Optional[pulumi.Input[builtins.str]] = None,
|
|
2211
|
+
counters: Optional[pulumi.Input[Mapping[str, pulumi.Input['CounterArgs']]]] = None):
|
|
2212
|
+
"""
|
|
2213
|
+
DeviceCounterConsumption defines a set of counters that a device will consume from a CounterSet.
|
|
2214
|
+
:param pulumi.Input[builtins.str] counter_set: CounterSet is the name of the set from which the counters defined will be consumed.
|
|
2215
|
+
:param pulumi.Input[Mapping[str, pulumi.Input['CounterArgs']]] counters: Counters defines the counters that will be consumed by the device.
|
|
2216
|
+
|
|
2217
|
+
The maximum number counters in a device is 32. In addition, the maximum number of all counters in all devices is 1024 (for example, 64 devices with 16 counters each).
|
|
2218
|
+
"""
|
|
2219
|
+
if counter_set is not None:
|
|
2220
|
+
pulumi.set(__self__, "counter_set", counter_set)
|
|
2221
|
+
if counters is not None:
|
|
2222
|
+
pulumi.set(__self__, "counters", counters)
|
|
2223
|
+
|
|
2224
|
+
@property
|
|
2225
|
+
@pulumi.getter(name="counterSet")
|
|
2226
|
+
def counter_set(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
2227
|
+
"""
|
|
2228
|
+
CounterSet is the name of the set from which the counters defined will be consumed.
|
|
2229
|
+
"""
|
|
2230
|
+
return pulumi.get(self, "counter_set")
|
|
2231
|
+
|
|
2232
|
+
@counter_set.setter
|
|
2233
|
+
def counter_set(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
2234
|
+
pulumi.set(self, "counter_set", value)
|
|
2235
|
+
|
|
2236
|
+
@property
|
|
2237
|
+
@pulumi.getter
|
|
2238
|
+
def counters(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input['CounterArgs']]]]:
|
|
2239
|
+
"""
|
|
2240
|
+
Counters defines the counters that will be consumed by the device.
|
|
2241
|
+
|
|
2242
|
+
The maximum number counters in a device is 32. In addition, the maximum number of all counters in all devices is 1024 (for example, 64 devices with 16 counters each).
|
|
2243
|
+
"""
|
|
2244
|
+
return pulumi.get(self, "counters")
|
|
2245
|
+
|
|
2246
|
+
@counters.setter
|
|
2247
|
+
def counters(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input['CounterArgs']]]]):
|
|
2248
|
+
pulumi.set(self, "counters", value)
|
|
2249
|
+
|
|
2250
|
+
|
|
2251
|
+
if not MYPY:
|
|
2252
|
+
class DeviceCounterConsumptionArgsDict(TypedDict):
|
|
2253
|
+
"""
|
|
2254
|
+
DeviceCounterConsumption defines a set of counters that a device will consume from a CounterSet.
|
|
2255
|
+
"""
|
|
2256
|
+
counter_set: pulumi.Input[builtins.str]
|
|
2257
|
+
"""
|
|
2258
|
+
CounterSet is the name of the set from which the counters defined will be consumed.
|
|
2259
|
+
"""
|
|
2260
|
+
counters: pulumi.Input[Mapping[str, pulumi.Input['CounterArgsDict']]]
|
|
2261
|
+
"""
|
|
2262
|
+
Counters defines the counters that will be consumed by the device.
|
|
2263
|
+
|
|
2264
|
+
The maximum number counters in a device is 32. In addition, the maximum number of all counters in all devices is 1024 (for example, 64 devices with 16 counters each).
|
|
2265
|
+
"""
|
|
2266
|
+
elif False:
|
|
2267
|
+
DeviceCounterConsumptionArgsDict: TypeAlias = Mapping[str, Any]
|
|
2268
|
+
|
|
2269
|
+
@pulumi.input_type
|
|
2270
|
+
class DeviceCounterConsumptionArgs:
|
|
2271
|
+
def __init__(__self__, *,
|
|
2272
|
+
counter_set: pulumi.Input[builtins.str],
|
|
2273
|
+
counters: pulumi.Input[Mapping[str, pulumi.Input['CounterArgs']]]):
|
|
2274
|
+
"""
|
|
2275
|
+
DeviceCounterConsumption defines a set of counters that a device will consume from a CounterSet.
|
|
2276
|
+
:param pulumi.Input[builtins.str] counter_set: CounterSet is the name of the set from which the counters defined will be consumed.
|
|
2277
|
+
:param pulumi.Input[Mapping[str, pulumi.Input['CounterArgs']]] counters: Counters defines the counters that will be consumed by the device.
|
|
2278
|
+
|
|
2279
|
+
The maximum number counters in a device is 32. In addition, the maximum number of all counters in all devices is 1024 (for example, 64 devices with 16 counters each).
|
|
2280
|
+
"""
|
|
2281
|
+
pulumi.set(__self__, "counter_set", counter_set)
|
|
2282
|
+
pulumi.set(__self__, "counters", counters)
|
|
2283
|
+
|
|
2284
|
+
@property
|
|
2285
|
+
@pulumi.getter(name="counterSet")
|
|
2286
|
+
def counter_set(self) -> pulumi.Input[builtins.str]:
|
|
2287
|
+
"""
|
|
2288
|
+
CounterSet is the name of the set from which the counters defined will be consumed.
|
|
2289
|
+
"""
|
|
2290
|
+
return pulumi.get(self, "counter_set")
|
|
2291
|
+
|
|
2292
|
+
@counter_set.setter
|
|
2293
|
+
def counter_set(self, value: pulumi.Input[builtins.str]):
|
|
2294
|
+
pulumi.set(self, "counter_set", value)
|
|
2295
|
+
|
|
2296
|
+
@property
|
|
2297
|
+
@pulumi.getter
|
|
2298
|
+
def counters(self) -> pulumi.Input[Mapping[str, pulumi.Input['CounterArgs']]]:
|
|
2299
|
+
"""
|
|
2300
|
+
Counters defines the counters that will be consumed by the device.
|
|
2301
|
+
|
|
2302
|
+
The maximum number counters in a device is 32. In addition, the maximum number of all counters in all devices is 1024 (for example, 64 devices with 16 counters each).
|
|
2303
|
+
"""
|
|
2304
|
+
return pulumi.get(self, "counters")
|
|
2305
|
+
|
|
2306
|
+
@counters.setter
|
|
2307
|
+
def counters(self, value: pulumi.Input[Mapping[str, pulumi.Input['CounterArgs']]]):
|
|
2308
|
+
pulumi.set(self, "counters", value)
|
|
2309
|
+
|
|
2310
|
+
|
|
1670
2311
|
if not MYPY:
|
|
1671
2312
|
class DevicePatchArgsDict(TypedDict):
|
|
1672
2313
|
"""
|
|
@@ -1746,7 +2387,9 @@ if not MYPY:
|
|
|
1746
2387
|
"""
|
|
1747
2388
|
request: pulumi.Input[builtins.str]
|
|
1748
2389
|
"""
|
|
1749
|
-
Request is the name of the request in the claim which caused this device to be allocated.
|
|
2390
|
+
Request is the name of the request in the claim which caused this device to be allocated. If it references a subrequest in the firstAvailable list on a DeviceRequest, this field must include both the name of the main request and the subrequest using the format <main request>/<subrequest>.
|
|
2391
|
+
|
|
2392
|
+
Multiple devices may have been allocated per request.
|
|
1750
2393
|
"""
|
|
1751
2394
|
admin_access: NotRequired[pulumi.Input[builtins.bool]]
|
|
1752
2395
|
"""
|
|
@@ -1754,6 +2397,14 @@ if not MYPY:
|
|
|
1754
2397
|
|
|
1755
2398
|
This is an alpha field and requires enabling the DRAAdminAccess feature gate. Admin access is disabled if this field is unset or set to false, otherwise it is enabled.
|
|
1756
2399
|
"""
|
|
2400
|
+
tolerations: NotRequired[pulumi.Input[Sequence[pulumi.Input['DeviceTolerationArgsDict']]]]
|
|
2401
|
+
"""
|
|
2402
|
+
A copy of all tolerations specified in the request at the time when the device got allocated.
|
|
2403
|
+
|
|
2404
|
+
The maximum number of tolerations is 16.
|
|
2405
|
+
|
|
2406
|
+
This is an alpha field and requires enabling the DRADeviceTaints feature gate.
|
|
2407
|
+
"""
|
|
1757
2408
|
elif False:
|
|
1758
2409
|
DeviceRequestAllocationResultArgsDict: TypeAlias = Mapping[str, Any]
|
|
1759
2410
|
|
|
@@ -1764,7 +2415,8 @@ class DeviceRequestAllocationResultArgs:
|
|
|
1764
2415
|
driver: pulumi.Input[builtins.str],
|
|
1765
2416
|
pool: pulumi.Input[builtins.str],
|
|
1766
2417
|
request: pulumi.Input[builtins.str],
|
|
1767
|
-
admin_access: Optional[pulumi.Input[builtins.bool]] = None
|
|
2418
|
+
admin_access: Optional[pulumi.Input[builtins.bool]] = None,
|
|
2419
|
+
tolerations: Optional[pulumi.Input[Sequence[pulumi.Input['DeviceTolerationArgs']]]] = None):
|
|
1768
2420
|
"""
|
|
1769
2421
|
DeviceRequestAllocationResult contains the allocation result for one request.
|
|
1770
2422
|
:param pulumi.Input[builtins.str] device: Device references one device instance via its name in the driver's resource pool. It must be a DNS label.
|
|
@@ -1774,10 +2426,17 @@ class DeviceRequestAllocationResultArgs:
|
|
|
1774
2426
|
:param pulumi.Input[builtins.str] pool: This name together with the driver name and the device name field identify which device was allocated (`<driver name>/<pool name>/<device name>`).
|
|
1775
2427
|
|
|
1776
2428
|
Must not be longer than 253 characters and may contain one or more DNS sub-domains separated by slashes.
|
|
1777
|
-
:param pulumi.Input[builtins.str] request: Request is the name of the request in the claim which caused this device to be allocated.
|
|
2429
|
+
:param pulumi.Input[builtins.str] request: Request is the name of the request in the claim which caused this device to be allocated. If it references a subrequest in the firstAvailable list on a DeviceRequest, this field must include both the name of the main request and the subrequest using the format <main request>/<subrequest>.
|
|
2430
|
+
|
|
2431
|
+
Multiple devices may have been allocated per request.
|
|
1778
2432
|
:param pulumi.Input[builtins.bool] admin_access: AdminAccess indicates that this device was allocated for administrative access. See the corresponding request field for a definition of mode.
|
|
1779
2433
|
|
|
1780
2434
|
This is an alpha field and requires enabling the DRAAdminAccess feature gate. Admin access is disabled if this field is unset or set to false, otherwise it is enabled.
|
|
2435
|
+
:param pulumi.Input[Sequence[pulumi.Input['DeviceTolerationArgs']]] tolerations: A copy of all tolerations specified in the request at the time when the device got allocated.
|
|
2436
|
+
|
|
2437
|
+
The maximum number of tolerations is 16.
|
|
2438
|
+
|
|
2439
|
+
This is an alpha field and requires enabling the DRADeviceTaints feature gate.
|
|
1781
2440
|
"""
|
|
1782
2441
|
pulumi.set(__self__, "device", device)
|
|
1783
2442
|
pulumi.set(__self__, "driver", driver)
|
|
@@ -1785,6 +2444,8 @@ class DeviceRequestAllocationResultArgs:
|
|
|
1785
2444
|
pulumi.set(__self__, "request", request)
|
|
1786
2445
|
if admin_access is not None:
|
|
1787
2446
|
pulumi.set(__self__, "admin_access", admin_access)
|
|
2447
|
+
if tolerations is not None:
|
|
2448
|
+
pulumi.set(__self__, "tolerations", tolerations)
|
|
1788
2449
|
|
|
1789
2450
|
@property
|
|
1790
2451
|
@pulumi.getter
|
|
@@ -1830,7 +2491,9 @@ class DeviceRequestAllocationResultArgs:
|
|
|
1830
2491
|
@pulumi.getter
|
|
1831
2492
|
def request(self) -> pulumi.Input[builtins.str]:
|
|
1832
2493
|
"""
|
|
1833
|
-
Request is the name of the request in the claim which caused this device to be allocated.
|
|
2494
|
+
Request is the name of the request in the claim which caused this device to be allocated. If it references a subrequest in the firstAvailable list on a DeviceRequest, this field must include both the name of the main request and the subrequest using the format <main request>/<subrequest>.
|
|
2495
|
+
|
|
2496
|
+
Multiple devices may have been allocated per request.
|
|
1834
2497
|
"""
|
|
1835
2498
|
return pulumi.get(self, "request")
|
|
1836
2499
|
|
|
@@ -1852,18 +2515,34 @@ class DeviceRequestAllocationResultArgs:
|
|
|
1852
2515
|
def admin_access(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
1853
2516
|
pulumi.set(self, "admin_access", value)
|
|
1854
2517
|
|
|
2518
|
+
@property
|
|
2519
|
+
@pulumi.getter
|
|
2520
|
+
def tolerations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DeviceTolerationArgs']]]]:
|
|
2521
|
+
"""
|
|
2522
|
+
A copy of all tolerations specified in the request at the time when the device got allocated.
|
|
2523
|
+
|
|
2524
|
+
The maximum number of tolerations is 16.
|
|
2525
|
+
|
|
2526
|
+
This is an alpha field and requires enabling the DRADeviceTaints feature gate.
|
|
2527
|
+
"""
|
|
2528
|
+
return pulumi.get(self, "tolerations")
|
|
2529
|
+
|
|
2530
|
+
@tolerations.setter
|
|
2531
|
+
def tolerations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DeviceTolerationArgs']]]]):
|
|
2532
|
+
pulumi.set(self, "tolerations", value)
|
|
2533
|
+
|
|
1855
2534
|
|
|
1856
2535
|
if not MYPY:
|
|
1857
2536
|
class DeviceRequestPatchArgsDict(TypedDict):
|
|
1858
2537
|
"""
|
|
1859
2538
|
DeviceRequest is a request for devices required for a claim. This is typically a request for a single resource like a device, but can also ask for several identical devices.
|
|
1860
|
-
|
|
1861
|
-
A DeviceClassName is currently required. Clients must check that it is indeed set. It's absence indicates that something changed in a way that is not supported by the client yet, in which case it must refuse to handle the request.
|
|
1862
2539
|
"""
|
|
1863
2540
|
admin_access: NotRequired[pulumi.Input[builtins.bool]]
|
|
1864
2541
|
"""
|
|
1865
2542
|
AdminAccess indicates that this is a claim for administrative access to the device(s). Claims with AdminAccess are expected to be used for monitoring or other management services for a device. They ignore all ordinary claims to the device with respect to access modes and any resource allocations.
|
|
1866
2543
|
|
|
2544
|
+
This field can only be set when deviceClassName is set and no subrequests are specified in the firstAvailable list.
|
|
2545
|
+
|
|
1867
2546
|
This is an alpha field and requires enabling the DRAAdminAccess feature gate. Admin access is disabled if this field is unset or set to false, otherwise it is enabled.
|
|
1868
2547
|
"""
|
|
1869
2548
|
allocation_mode: NotRequired[pulumi.Input[builtins.str]]
|
|
@@ -1875,34 +2554,63 @@ if not MYPY:
|
|
|
1875
2554
|
count field.
|
|
1876
2555
|
|
|
1877
2556
|
- All: This request is for all of the matching devices in a pool.
|
|
2557
|
+
At least one device must exist on the node for the allocation to succeed.
|
|
1878
2558
|
Allocation will fail if some devices are already allocated,
|
|
1879
2559
|
unless adminAccess is requested.
|
|
1880
2560
|
|
|
1881
|
-
If
|
|
2561
|
+
If AllocationMode is not specified, the default mode is ExactCount. If the mode is ExactCount and count is not specified, the default count is one. Any other requests must specify this field.
|
|
2562
|
+
|
|
2563
|
+
This field can only be set when deviceClassName is set and no subrequests are specified in the firstAvailable list.
|
|
1882
2564
|
|
|
1883
2565
|
More modes may get added in the future. Clients must refuse to handle requests with unknown modes.
|
|
1884
2566
|
"""
|
|
1885
2567
|
count: NotRequired[pulumi.Input[builtins.int]]
|
|
1886
2568
|
"""
|
|
1887
2569
|
Count is used only when the count mode is "ExactCount". Must be greater than zero. If AllocationMode is ExactCount and this field is not specified, the default is one.
|
|
2570
|
+
|
|
2571
|
+
This field can only be set when deviceClassName is set and no subrequests are specified in the firstAvailable list.
|
|
1888
2572
|
"""
|
|
1889
2573
|
device_class_name: NotRequired[pulumi.Input[builtins.str]]
|
|
1890
2574
|
"""
|
|
1891
2575
|
DeviceClassName references a specific DeviceClass, which can define additional configuration and selectors to be inherited by this request.
|
|
1892
2576
|
|
|
1893
|
-
A class is required. Which classes are available depends on the cluster.
|
|
2577
|
+
A class is required if no subrequests are specified in the firstAvailable list and no class can be set if subrequests are specified in the firstAvailable list. Which classes are available depends on the cluster.
|
|
1894
2578
|
|
|
1895
2579
|
Administrators may use this to restrict which devices may get requested by only installing classes with selectors for permitted devices. If users are free to request anything without restrictions, then administrators can create an empty DeviceClass for users to reference.
|
|
1896
2580
|
"""
|
|
2581
|
+
first_available: NotRequired[pulumi.Input[Sequence[pulumi.Input['DeviceSubRequestPatchArgsDict']]]]
|
|
2582
|
+
"""
|
|
2583
|
+
FirstAvailable contains subrequests, of which exactly one will be satisfied by the scheduler to satisfy this request. It tries to satisfy them in the order in which they are listed here. So if there are two entries in the list, the scheduler will only check the second one if it determines that the first one cannot be used.
|
|
2584
|
+
|
|
2585
|
+
This field may only be set in the entries of DeviceClaim.Requests.
|
|
2586
|
+
|
|
2587
|
+
DRA does not yet implement scoring, so the scheduler will select the first set of devices that satisfies all the requests in the claim. And if the requirements can be satisfied on more than one node, other scheduling features will determine which node is chosen. This means that the set of devices allocated to a claim might not be the optimal set available to the cluster. Scoring will be implemented later.
|
|
2588
|
+
"""
|
|
1897
2589
|
name: NotRequired[pulumi.Input[builtins.str]]
|
|
1898
2590
|
"""
|
|
1899
2591
|
Name can be used to reference this request in a pod.spec.containers[].resources.claims entry and in a constraint of the claim.
|
|
1900
2592
|
|
|
1901
|
-
Must be a DNS label.
|
|
2593
|
+
Must be a DNS label and unique among all DeviceRequests in a ResourceClaim.
|
|
1902
2594
|
"""
|
|
1903
2595
|
selectors: NotRequired[pulumi.Input[Sequence[pulumi.Input['DeviceSelectorPatchArgsDict']]]]
|
|
1904
2596
|
"""
|
|
1905
2597
|
Selectors define criteria which must be satisfied by a specific device in order for that device to be considered for this request. All selectors must be satisfied for a device to be considered.
|
|
2598
|
+
|
|
2599
|
+
This field can only be set when deviceClassName is set and no subrequests are specified in the firstAvailable list.
|
|
2600
|
+
"""
|
|
2601
|
+
tolerations: NotRequired[pulumi.Input[Sequence[pulumi.Input['DeviceTolerationPatchArgsDict']]]]
|
|
2602
|
+
"""
|
|
2603
|
+
If specified, the request's tolerations.
|
|
2604
|
+
|
|
2605
|
+
Tolerations for NoSchedule are required to allocate a device which has a taint with that effect. The same applies to NoExecute.
|
|
2606
|
+
|
|
2607
|
+
In addition, should any of the allocated devices get tainted with NoExecute after allocation and that effect is not tolerated, then all pods consuming the ResourceClaim get deleted to evict them. The scheduler will not let new pods reserve the claim while it has these tainted devices. Once all pods are evicted, the claim will get deallocated.
|
|
2608
|
+
|
|
2609
|
+
The maximum number of tolerations is 16.
|
|
2610
|
+
|
|
2611
|
+
This field can only be set when deviceClassName is set and no subrequests are specified in the firstAvailable list.
|
|
2612
|
+
|
|
2613
|
+
This is an alpha field and requires enabling the DRADeviceTaints feature gate.
|
|
1906
2614
|
"""
|
|
1907
2615
|
elif False:
|
|
1908
2616
|
DeviceRequestPatchArgsDict: TypeAlias = Mapping[str, Any]
|
|
@@ -1914,14 +2622,16 @@ class DeviceRequestPatchArgs:
|
|
|
1914
2622
|
allocation_mode: Optional[pulumi.Input[builtins.str]] = None,
|
|
1915
2623
|
count: Optional[pulumi.Input[builtins.int]] = None,
|
|
1916
2624
|
device_class_name: Optional[pulumi.Input[builtins.str]] = None,
|
|
2625
|
+
first_available: Optional[pulumi.Input[Sequence[pulumi.Input['DeviceSubRequestPatchArgs']]]] = None,
|
|
1917
2626
|
name: Optional[pulumi.Input[builtins.str]] = None,
|
|
1918
|
-
selectors: Optional[pulumi.Input[Sequence[pulumi.Input['DeviceSelectorPatchArgs']]]] = None
|
|
2627
|
+
selectors: Optional[pulumi.Input[Sequence[pulumi.Input['DeviceSelectorPatchArgs']]]] = None,
|
|
2628
|
+
tolerations: Optional[pulumi.Input[Sequence[pulumi.Input['DeviceTolerationPatchArgs']]]] = None):
|
|
1919
2629
|
"""
|
|
1920
2630
|
DeviceRequest is a request for devices required for a claim. This is typically a request for a single resource like a device, but can also ask for several identical devices.
|
|
1921
|
-
|
|
1922
|
-
A DeviceClassName is currently required. Clients must check that it is indeed set. It's absence indicates that something changed in a way that is not supported by the client yet, in which case it must refuse to handle the request.
|
|
1923
2631
|
:param pulumi.Input[builtins.bool] admin_access: AdminAccess indicates that this is a claim for administrative access to the device(s). Claims with AdminAccess are expected to be used for monitoring or other management services for a device. They ignore all ordinary claims to the device with respect to access modes and any resource allocations.
|
|
1924
2632
|
|
|
2633
|
+
This field can only be set when deviceClassName is set and no subrequests are specified in the firstAvailable list.
|
|
2634
|
+
|
|
1925
2635
|
This is an alpha field and requires enabling the DRAAdminAccess feature gate. Admin access is disabled if this field is unset or set to false, otherwise it is enabled.
|
|
1926
2636
|
:param pulumi.Input[builtins.str] allocation_mode: AllocationMode and its related fields define how devices are allocated to satisfy this request. Supported values are:
|
|
1927
2637
|
|
|
@@ -1930,22 +2640,45 @@ class DeviceRequestPatchArgs:
|
|
|
1930
2640
|
count field.
|
|
1931
2641
|
|
|
1932
2642
|
- All: This request is for all of the matching devices in a pool.
|
|
2643
|
+
At least one device must exist on the node for the allocation to succeed.
|
|
1933
2644
|
Allocation will fail if some devices are already allocated,
|
|
1934
2645
|
unless adminAccess is requested.
|
|
1935
2646
|
|
|
1936
|
-
If
|
|
2647
|
+
If AllocationMode is not specified, the default mode is ExactCount. If the mode is ExactCount and count is not specified, the default count is one. Any other requests must specify this field.
|
|
2648
|
+
|
|
2649
|
+
This field can only be set when deviceClassName is set and no subrequests are specified in the firstAvailable list.
|
|
1937
2650
|
|
|
1938
2651
|
More modes may get added in the future. Clients must refuse to handle requests with unknown modes.
|
|
1939
2652
|
:param pulumi.Input[builtins.int] count: Count is used only when the count mode is "ExactCount". Must be greater than zero. If AllocationMode is ExactCount and this field is not specified, the default is one.
|
|
2653
|
+
|
|
2654
|
+
This field can only be set when deviceClassName is set and no subrequests are specified in the firstAvailable list.
|
|
1940
2655
|
:param pulumi.Input[builtins.str] device_class_name: DeviceClassName references a specific DeviceClass, which can define additional configuration and selectors to be inherited by this request.
|
|
1941
2656
|
|
|
1942
|
-
A class is required. Which classes are available depends on the cluster.
|
|
2657
|
+
A class is required if no subrequests are specified in the firstAvailable list and no class can be set if subrequests are specified in the firstAvailable list. Which classes are available depends on the cluster.
|
|
1943
2658
|
|
|
1944
2659
|
Administrators may use this to restrict which devices may get requested by only installing classes with selectors for permitted devices. If users are free to request anything without restrictions, then administrators can create an empty DeviceClass for users to reference.
|
|
2660
|
+
:param pulumi.Input[Sequence[pulumi.Input['DeviceSubRequestPatchArgs']]] first_available: FirstAvailable contains subrequests, of which exactly one will be satisfied by the scheduler to satisfy this request. It tries to satisfy them in the order in which they are listed here. So if there are two entries in the list, the scheduler will only check the second one if it determines that the first one cannot be used.
|
|
2661
|
+
|
|
2662
|
+
This field may only be set in the entries of DeviceClaim.Requests.
|
|
2663
|
+
|
|
2664
|
+
DRA does not yet implement scoring, so the scheduler will select the first set of devices that satisfies all the requests in the claim. And if the requirements can be satisfied on more than one node, other scheduling features will determine which node is chosen. This means that the set of devices allocated to a claim might not be the optimal set available to the cluster. Scoring will be implemented later.
|
|
1945
2665
|
:param pulumi.Input[builtins.str] name: Name can be used to reference this request in a pod.spec.containers[].resources.claims entry and in a constraint of the claim.
|
|
1946
2666
|
|
|
1947
|
-
Must be a DNS label.
|
|
2667
|
+
Must be a DNS label and unique among all DeviceRequests in a ResourceClaim.
|
|
1948
2668
|
:param pulumi.Input[Sequence[pulumi.Input['DeviceSelectorPatchArgs']]] selectors: Selectors define criteria which must be satisfied by a specific device in order for that device to be considered for this request. All selectors must be satisfied for a device to be considered.
|
|
2669
|
+
|
|
2670
|
+
This field can only be set when deviceClassName is set and no subrequests are specified in the firstAvailable list.
|
|
2671
|
+
:param pulumi.Input[Sequence[pulumi.Input['DeviceTolerationPatchArgs']]] tolerations: If specified, the request's tolerations.
|
|
2672
|
+
|
|
2673
|
+
Tolerations for NoSchedule are required to allocate a device which has a taint with that effect. The same applies to NoExecute.
|
|
2674
|
+
|
|
2675
|
+
In addition, should any of the allocated devices get tainted with NoExecute after allocation and that effect is not tolerated, then all pods consuming the ResourceClaim get deleted to evict them. The scheduler will not let new pods reserve the claim while it has these tainted devices. Once all pods are evicted, the claim will get deallocated.
|
|
2676
|
+
|
|
2677
|
+
The maximum number of tolerations is 16.
|
|
2678
|
+
|
|
2679
|
+
This field can only be set when deviceClassName is set and no subrequests are specified in the firstAvailable list.
|
|
2680
|
+
|
|
2681
|
+
This is an alpha field and requires enabling the DRADeviceTaints feature gate.
|
|
1949
2682
|
"""
|
|
1950
2683
|
if admin_access is not None:
|
|
1951
2684
|
pulumi.set(__self__, "admin_access", admin_access)
|
|
@@ -1955,10 +2688,14 @@ class DeviceRequestPatchArgs:
|
|
|
1955
2688
|
pulumi.set(__self__, "count", count)
|
|
1956
2689
|
if device_class_name is not None:
|
|
1957
2690
|
pulumi.set(__self__, "device_class_name", device_class_name)
|
|
2691
|
+
if first_available is not None:
|
|
2692
|
+
pulumi.set(__self__, "first_available", first_available)
|
|
1958
2693
|
if name is not None:
|
|
1959
2694
|
pulumi.set(__self__, "name", name)
|
|
1960
2695
|
if selectors is not None:
|
|
1961
2696
|
pulumi.set(__self__, "selectors", selectors)
|
|
2697
|
+
if tolerations is not None:
|
|
2698
|
+
pulumi.set(__self__, "tolerations", tolerations)
|
|
1962
2699
|
|
|
1963
2700
|
@property
|
|
1964
2701
|
@pulumi.getter(name="adminAccess")
|
|
@@ -1966,6 +2703,8 @@ class DeviceRequestPatchArgs:
|
|
|
1966
2703
|
"""
|
|
1967
2704
|
AdminAccess indicates that this is a claim for administrative access to the device(s). Claims with AdminAccess are expected to be used for monitoring or other management services for a device. They ignore all ordinary claims to the device with respect to access modes and any resource allocations.
|
|
1968
2705
|
|
|
2706
|
+
This field can only be set when deviceClassName is set and no subrequests are specified in the firstAvailable list.
|
|
2707
|
+
|
|
1969
2708
|
This is an alpha field and requires enabling the DRAAdminAccess feature gate. Admin access is disabled if this field is unset or set to false, otherwise it is enabled.
|
|
1970
2709
|
"""
|
|
1971
2710
|
return pulumi.get(self, "admin_access")
|
|
@@ -1985,10 +2724,13 @@ class DeviceRequestPatchArgs:
|
|
|
1985
2724
|
count field.
|
|
1986
2725
|
|
|
1987
2726
|
- All: This request is for all of the matching devices in a pool.
|
|
2727
|
+
At least one device must exist on the node for the allocation to succeed.
|
|
1988
2728
|
Allocation will fail if some devices are already allocated,
|
|
1989
2729
|
unless adminAccess is requested.
|
|
1990
2730
|
|
|
1991
|
-
If
|
|
2731
|
+
If AllocationMode is not specified, the default mode is ExactCount. If the mode is ExactCount and count is not specified, the default count is one. Any other requests must specify this field.
|
|
2732
|
+
|
|
2733
|
+
This field can only be set when deviceClassName is set and no subrequests are specified in the firstAvailable list.
|
|
1992
2734
|
|
|
1993
2735
|
More modes may get added in the future. Clients must refuse to handle requests with unknown modes.
|
|
1994
2736
|
"""
|
|
@@ -2003,6 +2745,8 @@ class DeviceRequestPatchArgs:
|
|
|
2003
2745
|
def count(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
2004
2746
|
"""
|
|
2005
2747
|
Count is used only when the count mode is "ExactCount". Must be greater than zero. If AllocationMode is ExactCount and this field is not specified, the default is one.
|
|
2748
|
+
|
|
2749
|
+
This field can only be set when deviceClassName is set and no subrequests are specified in the firstAvailable list.
|
|
2006
2750
|
"""
|
|
2007
2751
|
return pulumi.get(self, "count")
|
|
2008
2752
|
|
|
@@ -2016,7 +2760,7 @@ class DeviceRequestPatchArgs:
|
|
|
2016
2760
|
"""
|
|
2017
2761
|
DeviceClassName references a specific DeviceClass, which can define additional configuration and selectors to be inherited by this request.
|
|
2018
2762
|
|
|
2019
|
-
A class is required. Which classes are available depends on the cluster.
|
|
2763
|
+
A class is required if no subrequests are specified in the firstAvailable list and no class can be set if subrequests are specified in the firstAvailable list. Which classes are available depends on the cluster.
|
|
2020
2764
|
|
|
2021
2765
|
Administrators may use this to restrict which devices may get requested by only installing classes with selectors for permitted devices. If users are free to request anything without restrictions, then administrators can create an empty DeviceClass for users to reference.
|
|
2022
2766
|
"""
|
|
@@ -2026,13 +2770,29 @@ class DeviceRequestPatchArgs:
|
|
|
2026
2770
|
def device_class_name(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
2027
2771
|
pulumi.set(self, "device_class_name", value)
|
|
2028
2772
|
|
|
2773
|
+
@property
|
|
2774
|
+
@pulumi.getter(name="firstAvailable")
|
|
2775
|
+
def first_available(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DeviceSubRequestPatchArgs']]]]:
|
|
2776
|
+
"""
|
|
2777
|
+
FirstAvailable contains subrequests, of which exactly one will be satisfied by the scheduler to satisfy this request. It tries to satisfy them in the order in which they are listed here. So if there are two entries in the list, the scheduler will only check the second one if it determines that the first one cannot be used.
|
|
2778
|
+
|
|
2779
|
+
This field may only be set in the entries of DeviceClaim.Requests.
|
|
2780
|
+
|
|
2781
|
+
DRA does not yet implement scoring, so the scheduler will select the first set of devices that satisfies all the requests in the claim. And if the requirements can be satisfied on more than one node, other scheduling features will determine which node is chosen. This means that the set of devices allocated to a claim might not be the optimal set available to the cluster. Scoring will be implemented later.
|
|
2782
|
+
"""
|
|
2783
|
+
return pulumi.get(self, "first_available")
|
|
2784
|
+
|
|
2785
|
+
@first_available.setter
|
|
2786
|
+
def first_available(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DeviceSubRequestPatchArgs']]]]):
|
|
2787
|
+
pulumi.set(self, "first_available", value)
|
|
2788
|
+
|
|
2029
2789
|
@property
|
|
2030
2790
|
@pulumi.getter
|
|
2031
2791
|
def name(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
2032
2792
|
"""
|
|
2033
2793
|
Name can be used to reference this request in a pod.spec.containers[].resources.claims entry and in a constraint of the claim.
|
|
2034
2794
|
|
|
2035
|
-
Must be a DNS label.
|
|
2795
|
+
Must be a DNS label and unique among all DeviceRequests in a ResourceClaim.
|
|
2036
2796
|
"""
|
|
2037
2797
|
return pulumi.get(self, "name")
|
|
2038
2798
|
|
|
@@ -2045,6 +2805,8 @@ class DeviceRequestPatchArgs:
|
|
|
2045
2805
|
def selectors(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DeviceSelectorPatchArgs']]]]:
|
|
2046
2806
|
"""
|
|
2047
2807
|
Selectors define criteria which must be satisfied by a specific device in order for that device to be considered for this request. All selectors must be satisfied for a device to be considered.
|
|
2808
|
+
|
|
2809
|
+
This field can only be set when deviceClassName is set and no subrequests are specified in the firstAvailable list.
|
|
2048
2810
|
"""
|
|
2049
2811
|
return pulumi.get(self, "selectors")
|
|
2050
2812
|
|
|
@@ -2052,32 +2814,46 @@ class DeviceRequestPatchArgs:
|
|
|
2052
2814
|
def selectors(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DeviceSelectorPatchArgs']]]]):
|
|
2053
2815
|
pulumi.set(self, "selectors", value)
|
|
2054
2816
|
|
|
2055
|
-
|
|
2056
|
-
|
|
2057
|
-
|
|
2817
|
+
@property
|
|
2818
|
+
@pulumi.getter
|
|
2819
|
+
def tolerations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DeviceTolerationPatchArgs']]]]:
|
|
2058
2820
|
"""
|
|
2059
|
-
|
|
2821
|
+
If specified, the request's tolerations.
|
|
2060
2822
|
|
|
2061
|
-
|
|
2062
|
-
|
|
2063
|
-
|
|
2823
|
+
Tolerations for NoSchedule are required to allocate a device which has a taint with that effect. The same applies to NoExecute.
|
|
2824
|
+
|
|
2825
|
+
In addition, should any of the allocated devices get tainted with NoExecute after allocation and that effect is not tolerated, then all pods consuming the ResourceClaim get deleted to evict them. The scheduler will not let new pods reserve the claim while it has these tainted devices. Once all pods are evicted, the claim will get deallocated.
|
|
2826
|
+
|
|
2827
|
+
The maximum number of tolerations is 16.
|
|
2828
|
+
|
|
2829
|
+
This field can only be set when deviceClassName is set and no subrequests are specified in the firstAvailable list.
|
|
2830
|
+
|
|
2831
|
+
This is an alpha field and requires enabling the DRADeviceTaints feature gate.
|
|
2064
2832
|
"""
|
|
2065
|
-
|
|
2833
|
+
return pulumi.get(self, "tolerations")
|
|
2066
2834
|
|
|
2067
|
-
|
|
2835
|
+
@tolerations.setter
|
|
2836
|
+
def tolerations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DeviceTolerationPatchArgs']]]]):
|
|
2837
|
+
pulumi.set(self, "tolerations", value)
|
|
2068
2838
|
|
|
2069
|
-
|
|
2839
|
+
|
|
2840
|
+
if not MYPY:
|
|
2841
|
+
class DeviceRequestArgsDict(TypedDict):
|
|
2842
|
+
"""
|
|
2843
|
+
DeviceRequest is a request for devices required for a claim. This is typically a request for a single resource like a device, but can also ask for several identical devices.
|
|
2070
2844
|
"""
|
|
2071
2845
|
name: pulumi.Input[builtins.str]
|
|
2072
2846
|
"""
|
|
2073
2847
|
Name can be used to reference this request in a pod.spec.containers[].resources.claims entry and in a constraint of the claim.
|
|
2074
2848
|
|
|
2075
|
-
Must be a DNS label.
|
|
2849
|
+
Must be a DNS label and unique among all DeviceRequests in a ResourceClaim.
|
|
2076
2850
|
"""
|
|
2077
2851
|
admin_access: NotRequired[pulumi.Input[builtins.bool]]
|
|
2078
2852
|
"""
|
|
2079
2853
|
AdminAccess indicates that this is a claim for administrative access to the device(s). Claims with AdminAccess are expected to be used for monitoring or other management services for a device. They ignore all ordinary claims to the device with respect to access modes and any resource allocations.
|
|
2080
2854
|
|
|
2855
|
+
This field can only be set when deviceClassName is set and no subrequests are specified in the firstAvailable list.
|
|
2856
|
+
|
|
2081
2857
|
This is an alpha field and requires enabling the DRAAdminAccess feature gate. Admin access is disabled if this field is unset or set to false, otherwise it is enabled.
|
|
2082
2858
|
"""
|
|
2083
2859
|
allocation_mode: NotRequired[pulumi.Input[builtins.str]]
|
|
@@ -2089,20 +2865,57 @@ if not MYPY:
|
|
|
2089
2865
|
count field.
|
|
2090
2866
|
|
|
2091
2867
|
- All: This request is for all of the matching devices in a pool.
|
|
2868
|
+
At least one device must exist on the node for the allocation to succeed.
|
|
2092
2869
|
Allocation will fail if some devices are already allocated,
|
|
2093
2870
|
unless adminAccess is requested.
|
|
2094
2871
|
|
|
2095
|
-
If
|
|
2872
|
+
If AllocationMode is not specified, the default mode is ExactCount. If the mode is ExactCount and count is not specified, the default count is one. Any other requests must specify this field.
|
|
2873
|
+
|
|
2874
|
+
This field can only be set when deviceClassName is set and no subrequests are specified in the firstAvailable list.
|
|
2096
2875
|
|
|
2097
2876
|
More modes may get added in the future. Clients must refuse to handle requests with unknown modes.
|
|
2098
2877
|
"""
|
|
2099
2878
|
count: NotRequired[pulumi.Input[builtins.int]]
|
|
2100
2879
|
"""
|
|
2101
2880
|
Count is used only when the count mode is "ExactCount". Must be greater than zero. If AllocationMode is ExactCount and this field is not specified, the default is one.
|
|
2881
|
+
|
|
2882
|
+
This field can only be set when deviceClassName is set and no subrequests are specified in the firstAvailable list.
|
|
2883
|
+
"""
|
|
2884
|
+
device_class_name: NotRequired[pulumi.Input[builtins.str]]
|
|
2885
|
+
"""
|
|
2886
|
+
DeviceClassName references a specific DeviceClass, which can define additional configuration and selectors to be inherited by this request.
|
|
2887
|
+
|
|
2888
|
+
A class is required if no subrequests are specified in the firstAvailable list and no class can be set if subrequests are specified in the firstAvailable list. Which classes are available depends on the cluster.
|
|
2889
|
+
|
|
2890
|
+
Administrators may use this to restrict which devices may get requested by only installing classes with selectors for permitted devices. If users are free to request anything without restrictions, then administrators can create an empty DeviceClass for users to reference.
|
|
2891
|
+
"""
|
|
2892
|
+
first_available: NotRequired[pulumi.Input[Sequence[pulumi.Input['DeviceSubRequestArgsDict']]]]
|
|
2893
|
+
"""
|
|
2894
|
+
FirstAvailable contains subrequests, of which exactly one will be satisfied by the scheduler to satisfy this request. It tries to satisfy them in the order in which they are listed here. So if there are two entries in the list, the scheduler will only check the second one if it determines that the first one cannot be used.
|
|
2895
|
+
|
|
2896
|
+
This field may only be set in the entries of DeviceClaim.Requests.
|
|
2897
|
+
|
|
2898
|
+
DRA does not yet implement scoring, so the scheduler will select the first set of devices that satisfies all the requests in the claim. And if the requirements can be satisfied on more than one node, other scheduling features will determine which node is chosen. This means that the set of devices allocated to a claim might not be the optimal set available to the cluster. Scoring will be implemented later.
|
|
2102
2899
|
"""
|
|
2103
2900
|
selectors: NotRequired[pulumi.Input[Sequence[pulumi.Input['DeviceSelectorArgsDict']]]]
|
|
2104
2901
|
"""
|
|
2105
2902
|
Selectors define criteria which must be satisfied by a specific device in order for that device to be considered for this request. All selectors must be satisfied for a device to be considered.
|
|
2903
|
+
|
|
2904
|
+
This field can only be set when deviceClassName is set and no subrequests are specified in the firstAvailable list.
|
|
2905
|
+
"""
|
|
2906
|
+
tolerations: NotRequired[pulumi.Input[Sequence[pulumi.Input['DeviceTolerationArgsDict']]]]
|
|
2907
|
+
"""
|
|
2908
|
+
If specified, the request's tolerations.
|
|
2909
|
+
|
|
2910
|
+
Tolerations for NoSchedule are required to allocate a device which has a taint with that effect. The same applies to NoExecute.
|
|
2911
|
+
|
|
2912
|
+
In addition, should any of the allocated devices get tainted with NoExecute after allocation and that effect is not tolerated, then all pods consuming the ResourceClaim get deleted to evict them. The scheduler will not let new pods reserve the claim while it has these tainted devices. Once all pods are evicted, the claim will get deallocated.
|
|
2913
|
+
|
|
2914
|
+
The maximum number of tolerations is 16.
|
|
2915
|
+
|
|
2916
|
+
This field can only be set when deviceClassName is set and no subrequests are specified in the firstAvailable list.
|
|
2917
|
+
|
|
2918
|
+
This is an alpha field and requires enabling the DRADeviceTaints feature gate.
|
|
2106
2919
|
"""
|
|
2107
2920
|
elif False:
|
|
2108
2921
|
DeviceRequestArgsDict: TypeAlias = Mapping[str, Any]
|
|
@@ -2110,26 +2923,23 @@ elif False:
|
|
|
2110
2923
|
@pulumi.input_type
|
|
2111
2924
|
class DeviceRequestArgs:
|
|
2112
2925
|
def __init__(__self__, *,
|
|
2113
|
-
device_class_name: pulumi.Input[builtins.str],
|
|
2114
2926
|
name: pulumi.Input[builtins.str],
|
|
2115
2927
|
admin_access: Optional[pulumi.Input[builtins.bool]] = None,
|
|
2116
2928
|
allocation_mode: Optional[pulumi.Input[builtins.str]] = None,
|
|
2117
2929
|
count: Optional[pulumi.Input[builtins.int]] = None,
|
|
2118
|
-
|
|
2930
|
+
device_class_name: Optional[pulumi.Input[builtins.str]] = None,
|
|
2931
|
+
first_available: Optional[pulumi.Input[Sequence[pulumi.Input['DeviceSubRequestArgs']]]] = None,
|
|
2932
|
+
selectors: Optional[pulumi.Input[Sequence[pulumi.Input['DeviceSelectorArgs']]]] = None,
|
|
2933
|
+
tolerations: Optional[pulumi.Input[Sequence[pulumi.Input['DeviceTolerationArgs']]]] = None):
|
|
2119
2934
|
"""
|
|
2120
2935
|
DeviceRequest is a request for devices required for a claim. This is typically a request for a single resource like a device, but can also ask for several identical devices.
|
|
2121
|
-
|
|
2122
|
-
A DeviceClassName is currently required. Clients must check that it is indeed set. It's absence indicates that something changed in a way that is not supported by the client yet, in which case it must refuse to handle the request.
|
|
2123
|
-
:param pulumi.Input[builtins.str] device_class_name: DeviceClassName references a specific DeviceClass, which can define additional configuration and selectors to be inherited by this request.
|
|
2124
|
-
|
|
2125
|
-
A class is required. Which classes are available depends on the cluster.
|
|
2126
|
-
|
|
2127
|
-
Administrators may use this to restrict which devices may get requested by only installing classes with selectors for permitted devices. If users are free to request anything without restrictions, then administrators can create an empty DeviceClass for users to reference.
|
|
2128
2936
|
:param pulumi.Input[builtins.str] name: Name can be used to reference this request in a pod.spec.containers[].resources.claims entry and in a constraint of the claim.
|
|
2129
2937
|
|
|
2130
|
-
Must be a DNS label.
|
|
2938
|
+
Must be a DNS label and unique among all DeviceRequests in a ResourceClaim.
|
|
2131
2939
|
:param pulumi.Input[builtins.bool] admin_access: AdminAccess indicates that this is a claim for administrative access to the device(s). Claims with AdminAccess are expected to be used for monitoring or other management services for a device. They ignore all ordinary claims to the device with respect to access modes and any resource allocations.
|
|
2132
2940
|
|
|
2941
|
+
This field can only be set when deviceClassName is set and no subrequests are specified in the firstAvailable list.
|
|
2942
|
+
|
|
2133
2943
|
This is an alpha field and requires enabling the DRAAdminAccess feature gate. Admin access is disabled if this field is unset or set to false, otherwise it is enabled.
|
|
2134
2944
|
:param pulumi.Input[builtins.str] allocation_mode: AllocationMode and its related fields define how devices are allocated to satisfy this request. Supported values are:
|
|
2135
2945
|
|
|
@@ -2138,16 +2948,43 @@ class DeviceRequestArgs:
|
|
|
2138
2948
|
count field.
|
|
2139
2949
|
|
|
2140
2950
|
- All: This request is for all of the matching devices in a pool.
|
|
2951
|
+
At least one device must exist on the node for the allocation to succeed.
|
|
2141
2952
|
Allocation will fail if some devices are already allocated,
|
|
2142
2953
|
unless adminAccess is requested.
|
|
2143
2954
|
|
|
2144
|
-
If
|
|
2955
|
+
If AllocationMode is not specified, the default mode is ExactCount. If the mode is ExactCount and count is not specified, the default count is one. Any other requests must specify this field.
|
|
2956
|
+
|
|
2957
|
+
This field can only be set when deviceClassName is set and no subrequests are specified in the firstAvailable list.
|
|
2145
2958
|
|
|
2146
2959
|
More modes may get added in the future. Clients must refuse to handle requests with unknown modes.
|
|
2147
2960
|
:param pulumi.Input[builtins.int] count: Count is used only when the count mode is "ExactCount". Must be greater than zero. If AllocationMode is ExactCount and this field is not specified, the default is one.
|
|
2961
|
+
|
|
2962
|
+
This field can only be set when deviceClassName is set and no subrequests are specified in the firstAvailable list.
|
|
2963
|
+
:param pulumi.Input[builtins.str] device_class_name: DeviceClassName references a specific DeviceClass, which can define additional configuration and selectors to be inherited by this request.
|
|
2964
|
+
|
|
2965
|
+
A class is required if no subrequests are specified in the firstAvailable list and no class can be set if subrequests are specified in the firstAvailable list. Which classes are available depends on the cluster.
|
|
2966
|
+
|
|
2967
|
+
Administrators may use this to restrict which devices may get requested by only installing classes with selectors for permitted devices. If users are free to request anything without restrictions, then administrators can create an empty DeviceClass for users to reference.
|
|
2968
|
+
:param pulumi.Input[Sequence[pulumi.Input['DeviceSubRequestArgs']]] first_available: FirstAvailable contains subrequests, of which exactly one will be satisfied by the scheduler to satisfy this request. It tries to satisfy them in the order in which they are listed here. So if there are two entries in the list, the scheduler will only check the second one if it determines that the first one cannot be used.
|
|
2969
|
+
|
|
2970
|
+
This field may only be set in the entries of DeviceClaim.Requests.
|
|
2971
|
+
|
|
2972
|
+
DRA does not yet implement scoring, so the scheduler will select the first set of devices that satisfies all the requests in the claim. And if the requirements can be satisfied on more than one node, other scheduling features will determine which node is chosen. This means that the set of devices allocated to a claim might not be the optimal set available to the cluster. Scoring will be implemented later.
|
|
2148
2973
|
:param pulumi.Input[Sequence[pulumi.Input['DeviceSelectorArgs']]] selectors: Selectors define criteria which must be satisfied by a specific device in order for that device to be considered for this request. All selectors must be satisfied for a device to be considered.
|
|
2974
|
+
|
|
2975
|
+
This field can only be set when deviceClassName is set and no subrequests are specified in the firstAvailable list.
|
|
2976
|
+
:param pulumi.Input[Sequence[pulumi.Input['DeviceTolerationArgs']]] tolerations: If specified, the request's tolerations.
|
|
2977
|
+
|
|
2978
|
+
Tolerations for NoSchedule are required to allocate a device which has a taint with that effect. The same applies to NoExecute.
|
|
2979
|
+
|
|
2980
|
+
In addition, should any of the allocated devices get tainted with NoExecute after allocation and that effect is not tolerated, then all pods consuming the ResourceClaim get deleted to evict them. The scheduler will not let new pods reserve the claim while it has these tainted devices. Once all pods are evicted, the claim will get deallocated.
|
|
2981
|
+
|
|
2982
|
+
The maximum number of tolerations is 16.
|
|
2983
|
+
|
|
2984
|
+
This field can only be set when deviceClassName is set and no subrequests are specified in the firstAvailable list.
|
|
2985
|
+
|
|
2986
|
+
This is an alpha field and requires enabling the DRADeviceTaints feature gate.
|
|
2149
2987
|
"""
|
|
2150
|
-
pulumi.set(__self__, "device_class_name", device_class_name)
|
|
2151
2988
|
pulumi.set(__self__, "name", name)
|
|
2152
2989
|
if admin_access is not None:
|
|
2153
2990
|
pulumi.set(__self__, "admin_access", admin_access)
|
|
@@ -2155,68 +2992,607 @@ class DeviceRequestArgs:
|
|
|
2155
2992
|
pulumi.set(__self__, "allocation_mode", allocation_mode)
|
|
2156
2993
|
if count is not None:
|
|
2157
2994
|
pulumi.set(__self__, "count", count)
|
|
2995
|
+
if device_class_name is not None:
|
|
2996
|
+
pulumi.set(__self__, "device_class_name", device_class_name)
|
|
2997
|
+
if first_available is not None:
|
|
2998
|
+
pulumi.set(__self__, "first_available", first_available)
|
|
2158
2999
|
if selectors is not None:
|
|
2159
3000
|
pulumi.set(__self__, "selectors", selectors)
|
|
3001
|
+
if tolerations is not None:
|
|
3002
|
+
pulumi.set(__self__, "tolerations", tolerations)
|
|
3003
|
+
|
|
3004
|
+
@property
|
|
3005
|
+
@pulumi.getter
|
|
3006
|
+
def name(self) -> pulumi.Input[builtins.str]:
|
|
3007
|
+
"""
|
|
3008
|
+
Name can be used to reference this request in a pod.spec.containers[].resources.claims entry and in a constraint of the claim.
|
|
3009
|
+
|
|
3010
|
+
Must be a DNS label and unique among all DeviceRequests in a ResourceClaim.
|
|
3011
|
+
"""
|
|
3012
|
+
return pulumi.get(self, "name")
|
|
3013
|
+
|
|
3014
|
+
@name.setter
|
|
3015
|
+
def name(self, value: pulumi.Input[builtins.str]):
|
|
3016
|
+
pulumi.set(self, "name", value)
|
|
3017
|
+
|
|
3018
|
+
@property
|
|
3019
|
+
@pulumi.getter(name="adminAccess")
|
|
3020
|
+
def admin_access(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
3021
|
+
"""
|
|
3022
|
+
AdminAccess indicates that this is a claim for administrative access to the device(s). Claims with AdminAccess are expected to be used for monitoring or other management services for a device. They ignore all ordinary claims to the device with respect to access modes and any resource allocations.
|
|
3023
|
+
|
|
3024
|
+
This field can only be set when deviceClassName is set and no subrequests are specified in the firstAvailable list.
|
|
3025
|
+
|
|
3026
|
+
This is an alpha field and requires enabling the DRAAdminAccess feature gate. Admin access is disabled if this field is unset or set to false, otherwise it is enabled.
|
|
3027
|
+
"""
|
|
3028
|
+
return pulumi.get(self, "admin_access")
|
|
3029
|
+
|
|
3030
|
+
@admin_access.setter
|
|
3031
|
+
def admin_access(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
3032
|
+
pulumi.set(self, "admin_access", value)
|
|
3033
|
+
|
|
3034
|
+
@property
|
|
3035
|
+
@pulumi.getter(name="allocationMode")
|
|
3036
|
+
def allocation_mode(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
3037
|
+
"""
|
|
3038
|
+
AllocationMode and its related fields define how devices are allocated to satisfy this request. Supported values are:
|
|
3039
|
+
|
|
3040
|
+
- ExactCount: This request is for a specific number of devices.
|
|
3041
|
+
This is the default. The exact number is provided in the
|
|
3042
|
+
count field.
|
|
3043
|
+
|
|
3044
|
+
- All: This request is for all of the matching devices in a pool.
|
|
3045
|
+
At least one device must exist on the node for the allocation to succeed.
|
|
3046
|
+
Allocation will fail if some devices are already allocated,
|
|
3047
|
+
unless adminAccess is requested.
|
|
3048
|
+
|
|
3049
|
+
If AllocationMode is not specified, the default mode is ExactCount. If the mode is ExactCount and count is not specified, the default count is one. Any other requests must specify this field.
|
|
3050
|
+
|
|
3051
|
+
This field can only be set when deviceClassName is set and no subrequests are specified in the firstAvailable list.
|
|
3052
|
+
|
|
3053
|
+
More modes may get added in the future. Clients must refuse to handle requests with unknown modes.
|
|
3054
|
+
"""
|
|
3055
|
+
return pulumi.get(self, "allocation_mode")
|
|
3056
|
+
|
|
3057
|
+
@allocation_mode.setter
|
|
3058
|
+
def allocation_mode(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
3059
|
+
pulumi.set(self, "allocation_mode", value)
|
|
3060
|
+
|
|
3061
|
+
@property
|
|
3062
|
+
@pulumi.getter
|
|
3063
|
+
def count(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
3064
|
+
"""
|
|
3065
|
+
Count is used only when the count mode is "ExactCount". Must be greater than zero. If AllocationMode is ExactCount and this field is not specified, the default is one.
|
|
3066
|
+
|
|
3067
|
+
This field can only be set when deviceClassName is set and no subrequests are specified in the firstAvailable list.
|
|
3068
|
+
"""
|
|
3069
|
+
return pulumi.get(self, "count")
|
|
3070
|
+
|
|
3071
|
+
@count.setter
|
|
3072
|
+
def count(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
3073
|
+
pulumi.set(self, "count", value)
|
|
2160
3074
|
|
|
2161
3075
|
@property
|
|
2162
3076
|
@pulumi.getter(name="deviceClassName")
|
|
2163
|
-
def device_class_name(self) -> pulumi.Input[builtins.str]:
|
|
3077
|
+
def device_class_name(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
2164
3078
|
"""
|
|
2165
3079
|
DeviceClassName references a specific DeviceClass, which can define additional configuration and selectors to be inherited by this request.
|
|
2166
3080
|
|
|
2167
|
-
A class is required. Which classes are available depends on the cluster.
|
|
3081
|
+
A class is required if no subrequests are specified in the firstAvailable list and no class can be set if subrequests are specified in the firstAvailable list. Which classes are available depends on the cluster.
|
|
2168
3082
|
|
|
2169
3083
|
Administrators may use this to restrict which devices may get requested by only installing classes with selectors for permitted devices. If users are free to request anything without restrictions, then administrators can create an empty DeviceClass for users to reference.
|
|
2170
3084
|
"""
|
|
2171
3085
|
return pulumi.get(self, "device_class_name")
|
|
2172
3086
|
|
|
2173
3087
|
@device_class_name.setter
|
|
2174
|
-
def device_class_name(self, value: pulumi.Input[builtins.str]):
|
|
3088
|
+
def device_class_name(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
2175
3089
|
pulumi.set(self, "device_class_name", value)
|
|
2176
3090
|
|
|
3091
|
+
@property
|
|
3092
|
+
@pulumi.getter(name="firstAvailable")
|
|
3093
|
+
def first_available(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DeviceSubRequestArgs']]]]:
|
|
3094
|
+
"""
|
|
3095
|
+
FirstAvailable contains subrequests, of which exactly one will be satisfied by the scheduler to satisfy this request. It tries to satisfy them in the order in which they are listed here. So if there are two entries in the list, the scheduler will only check the second one if it determines that the first one cannot be used.
|
|
3096
|
+
|
|
3097
|
+
This field may only be set in the entries of DeviceClaim.Requests.
|
|
3098
|
+
|
|
3099
|
+
DRA does not yet implement scoring, so the scheduler will select the first set of devices that satisfies all the requests in the claim. And if the requirements can be satisfied on more than one node, other scheduling features will determine which node is chosen. This means that the set of devices allocated to a claim might not be the optimal set available to the cluster. Scoring will be implemented later.
|
|
3100
|
+
"""
|
|
3101
|
+
return pulumi.get(self, "first_available")
|
|
3102
|
+
|
|
3103
|
+
@first_available.setter
|
|
3104
|
+
def first_available(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DeviceSubRequestArgs']]]]):
|
|
3105
|
+
pulumi.set(self, "first_available", value)
|
|
3106
|
+
|
|
2177
3107
|
@property
|
|
2178
3108
|
@pulumi.getter
|
|
2179
|
-
def
|
|
3109
|
+
def selectors(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DeviceSelectorArgs']]]]:
|
|
2180
3110
|
"""
|
|
2181
|
-
|
|
3111
|
+
Selectors define criteria which must be satisfied by a specific device in order for that device to be considered for this request. All selectors must be satisfied for a device to be considered.
|
|
2182
3112
|
|
|
2183
|
-
|
|
3113
|
+
This field can only be set when deviceClassName is set and no subrequests are specified in the firstAvailable list.
|
|
2184
3114
|
"""
|
|
2185
|
-
return pulumi.get(self, "
|
|
3115
|
+
return pulumi.get(self, "selectors")
|
|
2186
3116
|
|
|
2187
|
-
@
|
|
2188
|
-
def
|
|
2189
|
-
pulumi.set(self, "
|
|
3117
|
+
@selectors.setter
|
|
3118
|
+
def selectors(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DeviceSelectorArgs']]]]):
|
|
3119
|
+
pulumi.set(self, "selectors", value)
|
|
2190
3120
|
|
|
2191
3121
|
@property
|
|
2192
|
-
@pulumi.getter
|
|
2193
|
-
def
|
|
3122
|
+
@pulumi.getter
|
|
3123
|
+
def tolerations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DeviceTolerationArgs']]]]:
|
|
2194
3124
|
"""
|
|
2195
|
-
|
|
3125
|
+
If specified, the request's tolerations.
|
|
2196
3126
|
|
|
2197
|
-
|
|
3127
|
+
Tolerations for NoSchedule are required to allocate a device which has a taint with that effect. The same applies to NoExecute.
|
|
3128
|
+
|
|
3129
|
+
In addition, should any of the allocated devices get tainted with NoExecute after allocation and that effect is not tolerated, then all pods consuming the ResourceClaim get deleted to evict them. The scheduler will not let new pods reserve the claim while it has these tainted devices. Once all pods are evicted, the claim will get deallocated.
|
|
3130
|
+
|
|
3131
|
+
The maximum number of tolerations is 16.
|
|
3132
|
+
|
|
3133
|
+
This field can only be set when deviceClassName is set and no subrequests are specified in the firstAvailable list.
|
|
3134
|
+
|
|
3135
|
+
This is an alpha field and requires enabling the DRADeviceTaints feature gate.
|
|
3136
|
+
"""
|
|
3137
|
+
return pulumi.get(self, "tolerations")
|
|
3138
|
+
|
|
3139
|
+
@tolerations.setter
|
|
3140
|
+
def tolerations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DeviceTolerationArgs']]]]):
|
|
3141
|
+
pulumi.set(self, "tolerations", value)
|
|
3142
|
+
|
|
3143
|
+
|
|
3144
|
+
if not MYPY:
|
|
3145
|
+
class DeviceSelectorPatchArgsDict(TypedDict):
|
|
3146
|
+
"""
|
|
3147
|
+
DeviceSelector must have exactly one field set.
|
|
3148
|
+
"""
|
|
3149
|
+
cel: NotRequired[pulumi.Input['CELDeviceSelectorPatchArgsDict']]
|
|
3150
|
+
"""
|
|
3151
|
+
CEL contains a CEL expression for selecting a device.
|
|
3152
|
+
"""
|
|
3153
|
+
elif False:
|
|
3154
|
+
DeviceSelectorPatchArgsDict: TypeAlias = Mapping[str, Any]
|
|
3155
|
+
|
|
3156
|
+
@pulumi.input_type
|
|
3157
|
+
class DeviceSelectorPatchArgs:
|
|
3158
|
+
def __init__(__self__, *,
|
|
3159
|
+
cel: Optional[pulumi.Input['CELDeviceSelectorPatchArgs']] = None):
|
|
3160
|
+
"""
|
|
3161
|
+
DeviceSelector must have exactly one field set.
|
|
3162
|
+
:param pulumi.Input['CELDeviceSelectorPatchArgs'] cel: CEL contains a CEL expression for selecting a device.
|
|
3163
|
+
"""
|
|
3164
|
+
if cel is not None:
|
|
3165
|
+
pulumi.set(__self__, "cel", cel)
|
|
3166
|
+
|
|
3167
|
+
@property
|
|
3168
|
+
@pulumi.getter
|
|
3169
|
+
def cel(self) -> Optional[pulumi.Input['CELDeviceSelectorPatchArgs']]:
|
|
3170
|
+
"""
|
|
3171
|
+
CEL contains a CEL expression for selecting a device.
|
|
3172
|
+
"""
|
|
3173
|
+
return pulumi.get(self, "cel")
|
|
3174
|
+
|
|
3175
|
+
@cel.setter
|
|
3176
|
+
def cel(self, value: Optional[pulumi.Input['CELDeviceSelectorPatchArgs']]):
|
|
3177
|
+
pulumi.set(self, "cel", value)
|
|
3178
|
+
|
|
3179
|
+
|
|
3180
|
+
if not MYPY:
|
|
3181
|
+
class DeviceSelectorArgsDict(TypedDict):
|
|
3182
|
+
"""
|
|
3183
|
+
DeviceSelector must have exactly one field set.
|
|
3184
|
+
"""
|
|
3185
|
+
cel: NotRequired[pulumi.Input['CELDeviceSelectorArgsDict']]
|
|
3186
|
+
"""
|
|
3187
|
+
CEL contains a CEL expression for selecting a device.
|
|
3188
|
+
"""
|
|
3189
|
+
elif False:
|
|
3190
|
+
DeviceSelectorArgsDict: TypeAlias = Mapping[str, Any]
|
|
3191
|
+
|
|
3192
|
+
@pulumi.input_type
|
|
3193
|
+
class DeviceSelectorArgs:
|
|
3194
|
+
def __init__(__self__, *,
|
|
3195
|
+
cel: Optional[pulumi.Input['CELDeviceSelectorArgs']] = None):
|
|
3196
|
+
"""
|
|
3197
|
+
DeviceSelector must have exactly one field set.
|
|
3198
|
+
:param pulumi.Input['CELDeviceSelectorArgs'] cel: CEL contains a CEL expression for selecting a device.
|
|
3199
|
+
"""
|
|
3200
|
+
if cel is not None:
|
|
3201
|
+
pulumi.set(__self__, "cel", cel)
|
|
3202
|
+
|
|
3203
|
+
@property
|
|
3204
|
+
@pulumi.getter
|
|
3205
|
+
def cel(self) -> Optional[pulumi.Input['CELDeviceSelectorArgs']]:
|
|
3206
|
+
"""
|
|
3207
|
+
CEL contains a CEL expression for selecting a device.
|
|
3208
|
+
"""
|
|
3209
|
+
return pulumi.get(self, "cel")
|
|
3210
|
+
|
|
3211
|
+
@cel.setter
|
|
3212
|
+
def cel(self, value: Optional[pulumi.Input['CELDeviceSelectorArgs']]):
|
|
3213
|
+
pulumi.set(self, "cel", value)
|
|
3214
|
+
|
|
3215
|
+
|
|
3216
|
+
if not MYPY:
|
|
3217
|
+
class DeviceSubRequestPatchArgsDict(TypedDict):
|
|
3218
|
+
"""
|
|
3219
|
+
DeviceSubRequest describes a request for device provided in the claim.spec.devices.requests[].firstAvailable array. Each is typically a request for a single resource like a device, but can also ask for several identical devices.
|
|
3220
|
+
|
|
3221
|
+
DeviceSubRequest is similar to Request, but doesn't expose the AdminAccess or FirstAvailable fields, as those can only be set on the top-level request. AdminAccess is not supported for requests with a prioritized list, and recursive FirstAvailable fields are not supported.
|
|
3222
|
+
"""
|
|
3223
|
+
allocation_mode: NotRequired[pulumi.Input[builtins.str]]
|
|
3224
|
+
"""
|
|
3225
|
+
AllocationMode and its related fields define how devices are allocated to satisfy this subrequest. Supported values are:
|
|
3226
|
+
|
|
3227
|
+
- ExactCount: This request is for a specific number of devices.
|
|
3228
|
+
This is the default. The exact number is provided in the
|
|
3229
|
+
count field.
|
|
3230
|
+
|
|
3231
|
+
- All: This subrequest is for all of the matching devices in a pool.
|
|
3232
|
+
Allocation will fail if some devices are already allocated,
|
|
3233
|
+
unless adminAccess is requested.
|
|
3234
|
+
|
|
3235
|
+
If AllocationMode is not specified, the default mode is ExactCount. If the mode is ExactCount and count is not specified, the default count is one. Any other subrequests must specify this field.
|
|
3236
|
+
|
|
3237
|
+
More modes may get added in the future. Clients must refuse to handle requests with unknown modes.
|
|
3238
|
+
"""
|
|
3239
|
+
count: NotRequired[pulumi.Input[builtins.int]]
|
|
3240
|
+
"""
|
|
3241
|
+
Count is used only when the count mode is "ExactCount". Must be greater than zero. If AllocationMode is ExactCount and this field is not specified, the default is one.
|
|
3242
|
+
"""
|
|
3243
|
+
device_class_name: NotRequired[pulumi.Input[builtins.str]]
|
|
3244
|
+
"""
|
|
3245
|
+
DeviceClassName references a specific DeviceClass, which can define additional configuration and selectors to be inherited by this subrequest.
|
|
3246
|
+
|
|
3247
|
+
A class is required. Which classes are available depends on the cluster.
|
|
3248
|
+
|
|
3249
|
+
Administrators may use this to restrict which devices may get requested by only installing classes with selectors for permitted devices. If users are free to request anything without restrictions, then administrators can create an empty DeviceClass for users to reference.
|
|
3250
|
+
"""
|
|
3251
|
+
name: NotRequired[pulumi.Input[builtins.str]]
|
|
3252
|
+
"""
|
|
3253
|
+
Name can be used to reference this subrequest in the list of constraints or the list of configurations for the claim. References must use the format <main request>/<subrequest>.
|
|
3254
|
+
|
|
3255
|
+
Must be a DNS label.
|
|
3256
|
+
"""
|
|
3257
|
+
selectors: NotRequired[pulumi.Input[Sequence[pulumi.Input['DeviceSelectorPatchArgsDict']]]]
|
|
3258
|
+
"""
|
|
3259
|
+
Selectors define criteria which must be satisfied by a specific device in order for that device to be considered for this subrequest. All selectors must be satisfied for a device to be considered.
|
|
3260
|
+
"""
|
|
3261
|
+
tolerations: NotRequired[pulumi.Input[Sequence[pulumi.Input['DeviceTolerationPatchArgsDict']]]]
|
|
3262
|
+
"""
|
|
3263
|
+
If specified, the request's tolerations.
|
|
3264
|
+
|
|
3265
|
+
Tolerations for NoSchedule are required to allocate a device which has a taint with that effect. The same applies to NoExecute.
|
|
3266
|
+
|
|
3267
|
+
In addition, should any of the allocated devices get tainted with NoExecute after allocation and that effect is not tolerated, then all pods consuming the ResourceClaim get deleted to evict them. The scheduler will not let new pods reserve the claim while it has these tainted devices. Once all pods are evicted, the claim will get deallocated.
|
|
3268
|
+
|
|
3269
|
+
The maximum number of tolerations is 16.
|
|
3270
|
+
|
|
3271
|
+
This is an alpha field and requires enabling the DRADeviceTaints feature gate.
|
|
3272
|
+
"""
|
|
3273
|
+
elif False:
|
|
3274
|
+
DeviceSubRequestPatchArgsDict: TypeAlias = Mapping[str, Any]
|
|
3275
|
+
|
|
3276
|
+
@pulumi.input_type
|
|
3277
|
+
class DeviceSubRequestPatchArgs:
|
|
3278
|
+
def __init__(__self__, *,
|
|
3279
|
+
allocation_mode: Optional[pulumi.Input[builtins.str]] = None,
|
|
3280
|
+
count: Optional[pulumi.Input[builtins.int]] = None,
|
|
3281
|
+
device_class_name: Optional[pulumi.Input[builtins.str]] = None,
|
|
3282
|
+
name: Optional[pulumi.Input[builtins.str]] = None,
|
|
3283
|
+
selectors: Optional[pulumi.Input[Sequence[pulumi.Input['DeviceSelectorPatchArgs']]]] = None,
|
|
3284
|
+
tolerations: Optional[pulumi.Input[Sequence[pulumi.Input['DeviceTolerationPatchArgs']]]] = None):
|
|
3285
|
+
"""
|
|
3286
|
+
DeviceSubRequest describes a request for device provided in the claim.spec.devices.requests[].firstAvailable array. Each is typically a request for a single resource like a device, but can also ask for several identical devices.
|
|
3287
|
+
|
|
3288
|
+
DeviceSubRequest is similar to Request, but doesn't expose the AdminAccess or FirstAvailable fields, as those can only be set on the top-level request. AdminAccess is not supported for requests with a prioritized list, and recursive FirstAvailable fields are not supported.
|
|
3289
|
+
:param pulumi.Input[builtins.str] allocation_mode: AllocationMode and its related fields define how devices are allocated to satisfy this subrequest. Supported values are:
|
|
3290
|
+
|
|
3291
|
+
- ExactCount: This request is for a specific number of devices.
|
|
3292
|
+
This is the default. The exact number is provided in the
|
|
3293
|
+
count field.
|
|
3294
|
+
|
|
3295
|
+
- All: This subrequest is for all of the matching devices in a pool.
|
|
3296
|
+
Allocation will fail if some devices are already allocated,
|
|
3297
|
+
unless adminAccess is requested.
|
|
3298
|
+
|
|
3299
|
+
If AllocationMode is not specified, the default mode is ExactCount. If the mode is ExactCount and count is not specified, the default count is one. Any other subrequests must specify this field.
|
|
3300
|
+
|
|
3301
|
+
More modes may get added in the future. Clients must refuse to handle requests with unknown modes.
|
|
3302
|
+
:param pulumi.Input[builtins.int] count: Count is used only when the count mode is "ExactCount". Must be greater than zero. If AllocationMode is ExactCount and this field is not specified, the default is one.
|
|
3303
|
+
:param pulumi.Input[builtins.str] device_class_name: DeviceClassName references a specific DeviceClass, which can define additional configuration and selectors to be inherited by this subrequest.
|
|
3304
|
+
|
|
3305
|
+
A class is required. Which classes are available depends on the cluster.
|
|
3306
|
+
|
|
3307
|
+
Administrators may use this to restrict which devices may get requested by only installing classes with selectors for permitted devices. If users are free to request anything without restrictions, then administrators can create an empty DeviceClass for users to reference.
|
|
3308
|
+
:param pulumi.Input[builtins.str] name: Name can be used to reference this subrequest in the list of constraints or the list of configurations for the claim. References must use the format <main request>/<subrequest>.
|
|
3309
|
+
|
|
3310
|
+
Must be a DNS label.
|
|
3311
|
+
:param pulumi.Input[Sequence[pulumi.Input['DeviceSelectorPatchArgs']]] selectors: Selectors define criteria which must be satisfied by a specific device in order for that device to be considered for this subrequest. All selectors must be satisfied for a device to be considered.
|
|
3312
|
+
:param pulumi.Input[Sequence[pulumi.Input['DeviceTolerationPatchArgs']]] tolerations: If specified, the request's tolerations.
|
|
3313
|
+
|
|
3314
|
+
Tolerations for NoSchedule are required to allocate a device which has a taint with that effect. The same applies to NoExecute.
|
|
3315
|
+
|
|
3316
|
+
In addition, should any of the allocated devices get tainted with NoExecute after allocation and that effect is not tolerated, then all pods consuming the ResourceClaim get deleted to evict them. The scheduler will not let new pods reserve the claim while it has these tainted devices. Once all pods are evicted, the claim will get deallocated.
|
|
3317
|
+
|
|
3318
|
+
The maximum number of tolerations is 16.
|
|
3319
|
+
|
|
3320
|
+
This is an alpha field and requires enabling the DRADeviceTaints feature gate.
|
|
3321
|
+
"""
|
|
3322
|
+
if allocation_mode is not None:
|
|
3323
|
+
pulumi.set(__self__, "allocation_mode", allocation_mode)
|
|
3324
|
+
if count is not None:
|
|
3325
|
+
pulumi.set(__self__, "count", count)
|
|
3326
|
+
if device_class_name is not None:
|
|
3327
|
+
pulumi.set(__self__, "device_class_name", device_class_name)
|
|
3328
|
+
if name is not None:
|
|
3329
|
+
pulumi.set(__self__, "name", name)
|
|
3330
|
+
if selectors is not None:
|
|
3331
|
+
pulumi.set(__self__, "selectors", selectors)
|
|
3332
|
+
if tolerations is not None:
|
|
3333
|
+
pulumi.set(__self__, "tolerations", tolerations)
|
|
3334
|
+
|
|
3335
|
+
@property
|
|
3336
|
+
@pulumi.getter(name="allocationMode")
|
|
3337
|
+
def allocation_mode(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
3338
|
+
"""
|
|
3339
|
+
AllocationMode and its related fields define how devices are allocated to satisfy this subrequest. Supported values are:
|
|
3340
|
+
|
|
3341
|
+
- ExactCount: This request is for a specific number of devices.
|
|
3342
|
+
This is the default. The exact number is provided in the
|
|
3343
|
+
count field.
|
|
3344
|
+
|
|
3345
|
+
- All: This subrequest is for all of the matching devices in a pool.
|
|
3346
|
+
Allocation will fail if some devices are already allocated,
|
|
3347
|
+
unless adminAccess is requested.
|
|
3348
|
+
|
|
3349
|
+
If AllocationMode is not specified, the default mode is ExactCount. If the mode is ExactCount and count is not specified, the default count is one. Any other subrequests must specify this field.
|
|
3350
|
+
|
|
3351
|
+
More modes may get added in the future. Clients must refuse to handle requests with unknown modes.
|
|
3352
|
+
"""
|
|
3353
|
+
return pulumi.get(self, "allocation_mode")
|
|
3354
|
+
|
|
3355
|
+
@allocation_mode.setter
|
|
3356
|
+
def allocation_mode(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
3357
|
+
pulumi.set(self, "allocation_mode", value)
|
|
3358
|
+
|
|
3359
|
+
@property
|
|
3360
|
+
@pulumi.getter
|
|
3361
|
+
def count(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
3362
|
+
"""
|
|
3363
|
+
Count is used only when the count mode is "ExactCount". Must be greater than zero. If AllocationMode is ExactCount and this field is not specified, the default is one.
|
|
3364
|
+
"""
|
|
3365
|
+
return pulumi.get(self, "count")
|
|
3366
|
+
|
|
3367
|
+
@count.setter
|
|
3368
|
+
def count(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
3369
|
+
pulumi.set(self, "count", value)
|
|
3370
|
+
|
|
3371
|
+
@property
|
|
3372
|
+
@pulumi.getter(name="deviceClassName")
|
|
3373
|
+
def device_class_name(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
3374
|
+
"""
|
|
3375
|
+
DeviceClassName references a specific DeviceClass, which can define additional configuration and selectors to be inherited by this subrequest.
|
|
3376
|
+
|
|
3377
|
+
A class is required. Which classes are available depends on the cluster.
|
|
3378
|
+
|
|
3379
|
+
Administrators may use this to restrict which devices may get requested by only installing classes with selectors for permitted devices. If users are free to request anything without restrictions, then administrators can create an empty DeviceClass for users to reference.
|
|
3380
|
+
"""
|
|
3381
|
+
return pulumi.get(self, "device_class_name")
|
|
3382
|
+
|
|
3383
|
+
@device_class_name.setter
|
|
3384
|
+
def device_class_name(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
3385
|
+
pulumi.set(self, "device_class_name", value)
|
|
3386
|
+
|
|
3387
|
+
@property
|
|
3388
|
+
@pulumi.getter
|
|
3389
|
+
def name(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
3390
|
+
"""
|
|
3391
|
+
Name can be used to reference this subrequest in the list of constraints or the list of configurations for the claim. References must use the format <main request>/<subrequest>.
|
|
3392
|
+
|
|
3393
|
+
Must be a DNS label.
|
|
3394
|
+
"""
|
|
3395
|
+
return pulumi.get(self, "name")
|
|
3396
|
+
|
|
3397
|
+
@name.setter
|
|
3398
|
+
def name(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
3399
|
+
pulumi.set(self, "name", value)
|
|
3400
|
+
|
|
3401
|
+
@property
|
|
3402
|
+
@pulumi.getter
|
|
3403
|
+
def selectors(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DeviceSelectorPatchArgs']]]]:
|
|
3404
|
+
"""
|
|
3405
|
+
Selectors define criteria which must be satisfied by a specific device in order for that device to be considered for this subrequest. All selectors must be satisfied for a device to be considered.
|
|
3406
|
+
"""
|
|
3407
|
+
return pulumi.get(self, "selectors")
|
|
3408
|
+
|
|
3409
|
+
@selectors.setter
|
|
3410
|
+
def selectors(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DeviceSelectorPatchArgs']]]]):
|
|
3411
|
+
pulumi.set(self, "selectors", value)
|
|
3412
|
+
|
|
3413
|
+
@property
|
|
3414
|
+
@pulumi.getter
|
|
3415
|
+
def tolerations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DeviceTolerationPatchArgs']]]]:
|
|
3416
|
+
"""
|
|
3417
|
+
If specified, the request's tolerations.
|
|
3418
|
+
|
|
3419
|
+
Tolerations for NoSchedule are required to allocate a device which has a taint with that effect. The same applies to NoExecute.
|
|
3420
|
+
|
|
3421
|
+
In addition, should any of the allocated devices get tainted with NoExecute after allocation and that effect is not tolerated, then all pods consuming the ResourceClaim get deleted to evict them. The scheduler will not let new pods reserve the claim while it has these tainted devices. Once all pods are evicted, the claim will get deallocated.
|
|
3422
|
+
|
|
3423
|
+
The maximum number of tolerations is 16.
|
|
3424
|
+
|
|
3425
|
+
This is an alpha field and requires enabling the DRADeviceTaints feature gate.
|
|
3426
|
+
"""
|
|
3427
|
+
return pulumi.get(self, "tolerations")
|
|
3428
|
+
|
|
3429
|
+
@tolerations.setter
|
|
3430
|
+
def tolerations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DeviceTolerationPatchArgs']]]]):
|
|
3431
|
+
pulumi.set(self, "tolerations", value)
|
|
3432
|
+
|
|
3433
|
+
|
|
3434
|
+
if not MYPY:
|
|
3435
|
+
class DeviceSubRequestArgsDict(TypedDict):
|
|
3436
|
+
"""
|
|
3437
|
+
DeviceSubRequest describes a request for device provided in the claim.spec.devices.requests[].firstAvailable array. Each is typically a request for a single resource like a device, but can also ask for several identical devices.
|
|
3438
|
+
|
|
3439
|
+
DeviceSubRequest is similar to Request, but doesn't expose the AdminAccess or FirstAvailable fields, as those can only be set on the top-level request. AdminAccess is not supported for requests with a prioritized list, and recursive FirstAvailable fields are not supported.
|
|
3440
|
+
"""
|
|
3441
|
+
device_class_name: pulumi.Input[builtins.str]
|
|
3442
|
+
"""
|
|
3443
|
+
DeviceClassName references a specific DeviceClass, which can define additional configuration and selectors to be inherited by this subrequest.
|
|
3444
|
+
|
|
3445
|
+
A class is required. Which classes are available depends on the cluster.
|
|
3446
|
+
|
|
3447
|
+
Administrators may use this to restrict which devices may get requested by only installing classes with selectors for permitted devices. If users are free to request anything without restrictions, then administrators can create an empty DeviceClass for users to reference.
|
|
3448
|
+
"""
|
|
3449
|
+
name: pulumi.Input[builtins.str]
|
|
3450
|
+
"""
|
|
3451
|
+
Name can be used to reference this subrequest in the list of constraints or the list of configurations for the claim. References must use the format <main request>/<subrequest>.
|
|
3452
|
+
|
|
3453
|
+
Must be a DNS label.
|
|
3454
|
+
"""
|
|
3455
|
+
allocation_mode: NotRequired[pulumi.Input[builtins.str]]
|
|
3456
|
+
"""
|
|
3457
|
+
AllocationMode and its related fields define how devices are allocated to satisfy this subrequest. Supported values are:
|
|
3458
|
+
|
|
3459
|
+
- ExactCount: This request is for a specific number of devices.
|
|
3460
|
+
This is the default. The exact number is provided in the
|
|
3461
|
+
count field.
|
|
3462
|
+
|
|
3463
|
+
- All: This subrequest is for all of the matching devices in a pool.
|
|
3464
|
+
Allocation will fail if some devices are already allocated,
|
|
3465
|
+
unless adminAccess is requested.
|
|
3466
|
+
|
|
3467
|
+
If AllocationMode is not specified, the default mode is ExactCount. If the mode is ExactCount and count is not specified, the default count is one. Any other subrequests must specify this field.
|
|
3468
|
+
|
|
3469
|
+
More modes may get added in the future. Clients must refuse to handle requests with unknown modes.
|
|
3470
|
+
"""
|
|
3471
|
+
count: NotRequired[pulumi.Input[builtins.int]]
|
|
3472
|
+
"""
|
|
3473
|
+
Count is used only when the count mode is "ExactCount". Must be greater than zero. If AllocationMode is ExactCount and this field is not specified, the default is one.
|
|
3474
|
+
"""
|
|
3475
|
+
selectors: NotRequired[pulumi.Input[Sequence[pulumi.Input['DeviceSelectorArgsDict']]]]
|
|
3476
|
+
"""
|
|
3477
|
+
Selectors define criteria which must be satisfied by a specific device in order for that device to be considered for this subrequest. All selectors must be satisfied for a device to be considered.
|
|
3478
|
+
"""
|
|
3479
|
+
tolerations: NotRequired[pulumi.Input[Sequence[pulumi.Input['DeviceTolerationArgsDict']]]]
|
|
3480
|
+
"""
|
|
3481
|
+
If specified, the request's tolerations.
|
|
3482
|
+
|
|
3483
|
+
Tolerations for NoSchedule are required to allocate a device which has a taint with that effect. The same applies to NoExecute.
|
|
3484
|
+
|
|
3485
|
+
In addition, should any of the allocated devices get tainted with NoExecute after allocation and that effect is not tolerated, then all pods consuming the ResourceClaim get deleted to evict them. The scheduler will not let new pods reserve the claim while it has these tainted devices. Once all pods are evicted, the claim will get deallocated.
|
|
3486
|
+
|
|
3487
|
+
The maximum number of tolerations is 16.
|
|
3488
|
+
|
|
3489
|
+
This is an alpha field and requires enabling the DRADeviceTaints feature gate.
|
|
3490
|
+
"""
|
|
3491
|
+
elif False:
|
|
3492
|
+
DeviceSubRequestArgsDict: TypeAlias = Mapping[str, Any]
|
|
3493
|
+
|
|
3494
|
+
@pulumi.input_type
|
|
3495
|
+
class DeviceSubRequestArgs:
|
|
3496
|
+
def __init__(__self__, *,
|
|
3497
|
+
device_class_name: pulumi.Input[builtins.str],
|
|
3498
|
+
name: pulumi.Input[builtins.str],
|
|
3499
|
+
allocation_mode: Optional[pulumi.Input[builtins.str]] = None,
|
|
3500
|
+
count: Optional[pulumi.Input[builtins.int]] = None,
|
|
3501
|
+
selectors: Optional[pulumi.Input[Sequence[pulumi.Input['DeviceSelectorArgs']]]] = None,
|
|
3502
|
+
tolerations: Optional[pulumi.Input[Sequence[pulumi.Input['DeviceTolerationArgs']]]] = None):
|
|
3503
|
+
"""
|
|
3504
|
+
DeviceSubRequest describes a request for device provided in the claim.spec.devices.requests[].firstAvailable array. Each is typically a request for a single resource like a device, but can also ask for several identical devices.
|
|
3505
|
+
|
|
3506
|
+
DeviceSubRequest is similar to Request, but doesn't expose the AdminAccess or FirstAvailable fields, as those can only be set on the top-level request. AdminAccess is not supported for requests with a prioritized list, and recursive FirstAvailable fields are not supported.
|
|
3507
|
+
:param pulumi.Input[builtins.str] device_class_name: DeviceClassName references a specific DeviceClass, which can define additional configuration and selectors to be inherited by this subrequest.
|
|
3508
|
+
|
|
3509
|
+
A class is required. Which classes are available depends on the cluster.
|
|
3510
|
+
|
|
3511
|
+
Administrators may use this to restrict which devices may get requested by only installing classes with selectors for permitted devices. If users are free to request anything without restrictions, then administrators can create an empty DeviceClass for users to reference.
|
|
3512
|
+
:param pulumi.Input[builtins.str] name: Name can be used to reference this subrequest in the list of constraints or the list of configurations for the claim. References must use the format <main request>/<subrequest>.
|
|
3513
|
+
|
|
3514
|
+
Must be a DNS label.
|
|
3515
|
+
:param pulumi.Input[builtins.str] allocation_mode: AllocationMode and its related fields define how devices are allocated to satisfy this subrequest. Supported values are:
|
|
3516
|
+
|
|
3517
|
+
- ExactCount: This request is for a specific number of devices.
|
|
3518
|
+
This is the default. The exact number is provided in the
|
|
3519
|
+
count field.
|
|
3520
|
+
|
|
3521
|
+
- All: This subrequest is for all of the matching devices in a pool.
|
|
3522
|
+
Allocation will fail if some devices are already allocated,
|
|
3523
|
+
unless adminAccess is requested.
|
|
3524
|
+
|
|
3525
|
+
If AllocationMode is not specified, the default mode is ExactCount. If the mode is ExactCount and count is not specified, the default count is one. Any other subrequests must specify this field.
|
|
3526
|
+
|
|
3527
|
+
More modes may get added in the future. Clients must refuse to handle requests with unknown modes.
|
|
3528
|
+
:param pulumi.Input[builtins.int] count: Count is used only when the count mode is "ExactCount". Must be greater than zero. If AllocationMode is ExactCount and this field is not specified, the default is one.
|
|
3529
|
+
:param pulumi.Input[Sequence[pulumi.Input['DeviceSelectorArgs']]] selectors: Selectors define criteria which must be satisfied by a specific device in order for that device to be considered for this subrequest. All selectors must be satisfied for a device to be considered.
|
|
3530
|
+
:param pulumi.Input[Sequence[pulumi.Input['DeviceTolerationArgs']]] tolerations: If specified, the request's tolerations.
|
|
3531
|
+
|
|
3532
|
+
Tolerations for NoSchedule are required to allocate a device which has a taint with that effect. The same applies to NoExecute.
|
|
3533
|
+
|
|
3534
|
+
In addition, should any of the allocated devices get tainted with NoExecute after allocation and that effect is not tolerated, then all pods consuming the ResourceClaim get deleted to evict them. The scheduler will not let new pods reserve the claim while it has these tainted devices. Once all pods are evicted, the claim will get deallocated.
|
|
3535
|
+
|
|
3536
|
+
The maximum number of tolerations is 16.
|
|
3537
|
+
|
|
3538
|
+
This is an alpha field and requires enabling the DRADeviceTaints feature gate.
|
|
3539
|
+
"""
|
|
3540
|
+
pulumi.set(__self__, "device_class_name", device_class_name)
|
|
3541
|
+
pulumi.set(__self__, "name", name)
|
|
3542
|
+
if allocation_mode is not None:
|
|
3543
|
+
pulumi.set(__self__, "allocation_mode", allocation_mode)
|
|
3544
|
+
if count is not None:
|
|
3545
|
+
pulumi.set(__self__, "count", count)
|
|
3546
|
+
if selectors is not None:
|
|
3547
|
+
pulumi.set(__self__, "selectors", selectors)
|
|
3548
|
+
if tolerations is not None:
|
|
3549
|
+
pulumi.set(__self__, "tolerations", tolerations)
|
|
3550
|
+
|
|
3551
|
+
@property
|
|
3552
|
+
@pulumi.getter(name="deviceClassName")
|
|
3553
|
+
def device_class_name(self) -> pulumi.Input[builtins.str]:
|
|
3554
|
+
"""
|
|
3555
|
+
DeviceClassName references a specific DeviceClass, which can define additional configuration and selectors to be inherited by this subrequest.
|
|
3556
|
+
|
|
3557
|
+
A class is required. Which classes are available depends on the cluster.
|
|
3558
|
+
|
|
3559
|
+
Administrators may use this to restrict which devices may get requested by only installing classes with selectors for permitted devices. If users are free to request anything without restrictions, then administrators can create an empty DeviceClass for users to reference.
|
|
3560
|
+
"""
|
|
3561
|
+
return pulumi.get(self, "device_class_name")
|
|
3562
|
+
|
|
3563
|
+
@device_class_name.setter
|
|
3564
|
+
def device_class_name(self, value: pulumi.Input[builtins.str]):
|
|
3565
|
+
pulumi.set(self, "device_class_name", value)
|
|
3566
|
+
|
|
3567
|
+
@property
|
|
3568
|
+
@pulumi.getter
|
|
3569
|
+
def name(self) -> pulumi.Input[builtins.str]:
|
|
3570
|
+
"""
|
|
3571
|
+
Name can be used to reference this subrequest in the list of constraints or the list of configurations for the claim. References must use the format <main request>/<subrequest>.
|
|
3572
|
+
|
|
3573
|
+
Must be a DNS label.
|
|
2198
3574
|
"""
|
|
2199
|
-
return pulumi.get(self, "
|
|
3575
|
+
return pulumi.get(self, "name")
|
|
2200
3576
|
|
|
2201
|
-
@
|
|
2202
|
-
def
|
|
2203
|
-
pulumi.set(self, "
|
|
3577
|
+
@name.setter
|
|
3578
|
+
def name(self, value: pulumi.Input[builtins.str]):
|
|
3579
|
+
pulumi.set(self, "name", value)
|
|
2204
3580
|
|
|
2205
3581
|
@property
|
|
2206
3582
|
@pulumi.getter(name="allocationMode")
|
|
2207
3583
|
def allocation_mode(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
2208
3584
|
"""
|
|
2209
|
-
AllocationMode and its related fields define how devices are allocated to satisfy this
|
|
3585
|
+
AllocationMode and its related fields define how devices are allocated to satisfy this subrequest. Supported values are:
|
|
2210
3586
|
|
|
2211
3587
|
- ExactCount: This request is for a specific number of devices.
|
|
2212
3588
|
This is the default. The exact number is provided in the
|
|
2213
3589
|
count field.
|
|
2214
3590
|
|
|
2215
|
-
- All: This
|
|
3591
|
+
- All: This subrequest is for all of the matching devices in a pool.
|
|
2216
3592
|
Allocation will fail if some devices are already allocated,
|
|
2217
3593
|
unless adminAccess is requested.
|
|
2218
3594
|
|
|
2219
|
-
If
|
|
3595
|
+
If AllocationMode is not specified, the default mode is ExactCount. If the mode is ExactCount and count is not specified, the default count is one. Any other subrequests must specify this field.
|
|
2220
3596
|
|
|
2221
3597
|
More modes may get added in the future. Clients must refuse to handle requests with unknown modes.
|
|
2222
3598
|
"""
|
|
@@ -2242,7 +3618,7 @@ class DeviceRequestArgs:
|
|
|
2242
3618
|
@pulumi.getter
|
|
2243
3619
|
def selectors(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DeviceSelectorArgs']]]]:
|
|
2244
3620
|
"""
|
|
2245
|
-
Selectors define criteria which must be satisfied by a specific device in order for that device to be considered for this
|
|
3621
|
+
Selectors define criteria which must be satisfied by a specific device in order for that device to be considered for this subrequest. All selectors must be satisfied for a device to be considered.
|
|
2246
3622
|
"""
|
|
2247
3623
|
return pulumi.get(self, "selectors")
|
|
2248
3624
|
|
|
@@ -2250,77 +3626,447 @@ class DeviceRequestArgs:
|
|
|
2250
3626
|
def selectors(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DeviceSelectorArgs']]]]):
|
|
2251
3627
|
pulumi.set(self, "selectors", value)
|
|
2252
3628
|
|
|
3629
|
+
@property
|
|
3630
|
+
@pulumi.getter
|
|
3631
|
+
def tolerations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DeviceTolerationArgs']]]]:
|
|
3632
|
+
"""
|
|
3633
|
+
If specified, the request's tolerations.
|
|
3634
|
+
|
|
3635
|
+
Tolerations for NoSchedule are required to allocate a device which has a taint with that effect. The same applies to NoExecute.
|
|
3636
|
+
|
|
3637
|
+
In addition, should any of the allocated devices get tainted with NoExecute after allocation and that effect is not tolerated, then all pods consuming the ResourceClaim get deleted to evict them. The scheduler will not let new pods reserve the claim while it has these tainted devices. Once all pods are evicted, the claim will get deallocated.
|
|
3638
|
+
|
|
3639
|
+
The maximum number of tolerations is 16.
|
|
3640
|
+
|
|
3641
|
+
This is an alpha field and requires enabling the DRADeviceTaints feature gate.
|
|
3642
|
+
"""
|
|
3643
|
+
return pulumi.get(self, "tolerations")
|
|
3644
|
+
|
|
3645
|
+
@tolerations.setter
|
|
3646
|
+
def tolerations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DeviceTolerationArgs']]]]):
|
|
3647
|
+
pulumi.set(self, "tolerations", value)
|
|
3648
|
+
|
|
2253
3649
|
|
|
2254
3650
|
if not MYPY:
|
|
2255
|
-
class
|
|
3651
|
+
class DeviceTaintPatchArgsDict(TypedDict):
|
|
2256
3652
|
"""
|
|
2257
|
-
|
|
3653
|
+
The device this taint is attached to has the "effect" on any claim which does not tolerate the taint and, through the claim, to pods using the claim.
|
|
2258
3654
|
"""
|
|
2259
|
-
|
|
3655
|
+
effect: NotRequired[pulumi.Input[builtins.str]]
|
|
2260
3656
|
"""
|
|
2261
|
-
|
|
3657
|
+
The effect of the taint on claims that do not tolerate the taint and through such claims on the pods using them. Valid effects are NoSchedule and NoExecute. PreferNoSchedule as used for nodes is not valid here.
|
|
3658
|
+
"""
|
|
3659
|
+
key: NotRequired[pulumi.Input[builtins.str]]
|
|
3660
|
+
"""
|
|
3661
|
+
The taint key to be applied to a device. Must be a label name.
|
|
3662
|
+
"""
|
|
3663
|
+
time_added: NotRequired[pulumi.Input[builtins.str]]
|
|
3664
|
+
"""
|
|
3665
|
+
TimeAdded represents the time at which the taint was added. Added automatically during create or update if not set.
|
|
3666
|
+
"""
|
|
3667
|
+
value: NotRequired[pulumi.Input[builtins.str]]
|
|
3668
|
+
"""
|
|
3669
|
+
The taint value corresponding to the taint key. Must be a label value.
|
|
2262
3670
|
"""
|
|
2263
3671
|
elif False:
|
|
2264
|
-
|
|
3672
|
+
DeviceTaintPatchArgsDict: TypeAlias = Mapping[str, Any]
|
|
2265
3673
|
|
|
2266
3674
|
@pulumi.input_type
|
|
2267
|
-
class
|
|
3675
|
+
class DeviceTaintPatchArgs:
|
|
2268
3676
|
def __init__(__self__, *,
|
|
2269
|
-
|
|
3677
|
+
effect: Optional[pulumi.Input[builtins.str]] = None,
|
|
3678
|
+
key: Optional[pulumi.Input[builtins.str]] = None,
|
|
3679
|
+
time_added: Optional[pulumi.Input[builtins.str]] = None,
|
|
3680
|
+
value: Optional[pulumi.Input[builtins.str]] = None):
|
|
3681
|
+
"""
|
|
3682
|
+
The device this taint is attached to has the "effect" on any claim which does not tolerate the taint and, through the claim, to pods using the claim.
|
|
3683
|
+
:param pulumi.Input[builtins.str] effect: The effect of the taint on claims that do not tolerate the taint and through such claims on the pods using them. Valid effects are NoSchedule and NoExecute. PreferNoSchedule as used for nodes is not valid here.
|
|
3684
|
+
:param pulumi.Input[builtins.str] key: The taint key to be applied to a device. Must be a label name.
|
|
3685
|
+
:param pulumi.Input[builtins.str] time_added: TimeAdded represents the time at which the taint was added. Added automatically during create or update if not set.
|
|
3686
|
+
:param pulumi.Input[builtins.str] value: The taint value corresponding to the taint key. Must be a label value.
|
|
3687
|
+
"""
|
|
3688
|
+
if effect is not None:
|
|
3689
|
+
pulumi.set(__self__, "effect", effect)
|
|
3690
|
+
if key is not None:
|
|
3691
|
+
pulumi.set(__self__, "key", key)
|
|
3692
|
+
if time_added is not None:
|
|
3693
|
+
pulumi.set(__self__, "time_added", time_added)
|
|
3694
|
+
if value is not None:
|
|
3695
|
+
pulumi.set(__self__, "value", value)
|
|
3696
|
+
|
|
3697
|
+
@property
|
|
3698
|
+
@pulumi.getter
|
|
3699
|
+
def effect(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
2270
3700
|
"""
|
|
2271
|
-
|
|
2272
|
-
:param pulumi.Input['CELDeviceSelectorPatchArgs'] cel: CEL contains a CEL expression for selecting a device.
|
|
3701
|
+
The effect of the taint on claims that do not tolerate the taint and through such claims on the pods using them. Valid effects are NoSchedule and NoExecute. PreferNoSchedule as used for nodes is not valid here.
|
|
2273
3702
|
"""
|
|
2274
|
-
|
|
2275
|
-
|
|
3703
|
+
return pulumi.get(self, "effect")
|
|
3704
|
+
|
|
3705
|
+
@effect.setter
|
|
3706
|
+
def effect(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
3707
|
+
pulumi.set(self, "effect", value)
|
|
2276
3708
|
|
|
2277
3709
|
@property
|
|
2278
3710
|
@pulumi.getter
|
|
2279
|
-
def
|
|
3711
|
+
def key(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
2280
3712
|
"""
|
|
2281
|
-
|
|
3713
|
+
The taint key to be applied to a device. Must be a label name.
|
|
2282
3714
|
"""
|
|
2283
|
-
return pulumi.get(self, "
|
|
3715
|
+
return pulumi.get(self, "key")
|
|
2284
3716
|
|
|
2285
|
-
@
|
|
2286
|
-
def
|
|
2287
|
-
pulumi.set(self, "
|
|
3717
|
+
@key.setter
|
|
3718
|
+
def key(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
3719
|
+
pulumi.set(self, "key", value)
|
|
3720
|
+
|
|
3721
|
+
@property
|
|
3722
|
+
@pulumi.getter(name="timeAdded")
|
|
3723
|
+
def time_added(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
3724
|
+
"""
|
|
3725
|
+
TimeAdded represents the time at which the taint was added. Added automatically during create or update if not set.
|
|
3726
|
+
"""
|
|
3727
|
+
return pulumi.get(self, "time_added")
|
|
3728
|
+
|
|
3729
|
+
@time_added.setter
|
|
3730
|
+
def time_added(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
3731
|
+
pulumi.set(self, "time_added", value)
|
|
3732
|
+
|
|
3733
|
+
@property
|
|
3734
|
+
@pulumi.getter
|
|
3735
|
+
def value(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
3736
|
+
"""
|
|
3737
|
+
The taint value corresponding to the taint key. Must be a label value.
|
|
3738
|
+
"""
|
|
3739
|
+
return pulumi.get(self, "value")
|
|
3740
|
+
|
|
3741
|
+
@value.setter
|
|
3742
|
+
def value(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
3743
|
+
pulumi.set(self, "value", value)
|
|
2288
3744
|
|
|
2289
3745
|
|
|
2290
3746
|
if not MYPY:
|
|
2291
|
-
class
|
|
3747
|
+
class DeviceTaintArgsDict(TypedDict):
|
|
2292
3748
|
"""
|
|
2293
|
-
|
|
3749
|
+
The device this taint is attached to has the "effect" on any claim which does not tolerate the taint and, through the claim, to pods using the claim.
|
|
2294
3750
|
"""
|
|
2295
|
-
|
|
3751
|
+
effect: pulumi.Input[builtins.str]
|
|
2296
3752
|
"""
|
|
2297
|
-
|
|
3753
|
+
The effect of the taint on claims that do not tolerate the taint and through such claims on the pods using them. Valid effects are NoSchedule and NoExecute. PreferNoSchedule as used for nodes is not valid here.
|
|
3754
|
+
"""
|
|
3755
|
+
key: pulumi.Input[builtins.str]
|
|
3756
|
+
"""
|
|
3757
|
+
The taint key to be applied to a device. Must be a label name.
|
|
3758
|
+
"""
|
|
3759
|
+
time_added: NotRequired[pulumi.Input[builtins.str]]
|
|
3760
|
+
"""
|
|
3761
|
+
TimeAdded represents the time at which the taint was added. Added automatically during create or update if not set.
|
|
3762
|
+
"""
|
|
3763
|
+
value: NotRequired[pulumi.Input[builtins.str]]
|
|
3764
|
+
"""
|
|
3765
|
+
The taint value corresponding to the taint key. Must be a label value.
|
|
2298
3766
|
"""
|
|
2299
3767
|
elif False:
|
|
2300
|
-
|
|
3768
|
+
DeviceTaintArgsDict: TypeAlias = Mapping[str, Any]
|
|
2301
3769
|
|
|
2302
3770
|
@pulumi.input_type
|
|
2303
|
-
class
|
|
3771
|
+
class DeviceTaintArgs:
|
|
2304
3772
|
def __init__(__self__, *,
|
|
2305
|
-
|
|
3773
|
+
effect: pulumi.Input[builtins.str],
|
|
3774
|
+
key: pulumi.Input[builtins.str],
|
|
3775
|
+
time_added: Optional[pulumi.Input[builtins.str]] = None,
|
|
3776
|
+
value: Optional[pulumi.Input[builtins.str]] = None):
|
|
3777
|
+
"""
|
|
3778
|
+
The device this taint is attached to has the "effect" on any claim which does not tolerate the taint and, through the claim, to pods using the claim.
|
|
3779
|
+
:param pulumi.Input[builtins.str] effect: The effect of the taint on claims that do not tolerate the taint and through such claims on the pods using them. Valid effects are NoSchedule and NoExecute. PreferNoSchedule as used for nodes is not valid here.
|
|
3780
|
+
:param pulumi.Input[builtins.str] key: The taint key to be applied to a device. Must be a label name.
|
|
3781
|
+
:param pulumi.Input[builtins.str] time_added: TimeAdded represents the time at which the taint was added. Added automatically during create or update if not set.
|
|
3782
|
+
:param pulumi.Input[builtins.str] value: The taint value corresponding to the taint key. Must be a label value.
|
|
3783
|
+
"""
|
|
3784
|
+
pulumi.set(__self__, "effect", effect)
|
|
3785
|
+
pulumi.set(__self__, "key", key)
|
|
3786
|
+
if time_added is not None:
|
|
3787
|
+
pulumi.set(__self__, "time_added", time_added)
|
|
3788
|
+
if value is not None:
|
|
3789
|
+
pulumi.set(__self__, "value", value)
|
|
3790
|
+
|
|
3791
|
+
@property
|
|
3792
|
+
@pulumi.getter
|
|
3793
|
+
def effect(self) -> pulumi.Input[builtins.str]:
|
|
2306
3794
|
"""
|
|
2307
|
-
|
|
2308
|
-
:param pulumi.Input['CELDeviceSelectorArgs'] cel: CEL contains a CEL expression for selecting a device.
|
|
3795
|
+
The effect of the taint on claims that do not tolerate the taint and through such claims on the pods using them. Valid effects are NoSchedule and NoExecute. PreferNoSchedule as used for nodes is not valid here.
|
|
2309
3796
|
"""
|
|
2310
|
-
|
|
2311
|
-
|
|
3797
|
+
return pulumi.get(self, "effect")
|
|
3798
|
+
|
|
3799
|
+
@effect.setter
|
|
3800
|
+
def effect(self, value: pulumi.Input[builtins.str]):
|
|
3801
|
+
pulumi.set(self, "effect", value)
|
|
2312
3802
|
|
|
2313
3803
|
@property
|
|
2314
3804
|
@pulumi.getter
|
|
2315
|
-
def
|
|
3805
|
+
def key(self) -> pulumi.Input[builtins.str]:
|
|
2316
3806
|
"""
|
|
2317
|
-
|
|
3807
|
+
The taint key to be applied to a device. Must be a label name.
|
|
2318
3808
|
"""
|
|
2319
|
-
return pulumi.get(self, "
|
|
3809
|
+
return pulumi.get(self, "key")
|
|
2320
3810
|
|
|
2321
|
-
@
|
|
2322
|
-
def
|
|
2323
|
-
pulumi.set(self, "
|
|
3811
|
+
@key.setter
|
|
3812
|
+
def key(self, value: pulumi.Input[builtins.str]):
|
|
3813
|
+
pulumi.set(self, "key", value)
|
|
3814
|
+
|
|
3815
|
+
@property
|
|
3816
|
+
@pulumi.getter(name="timeAdded")
|
|
3817
|
+
def time_added(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
3818
|
+
"""
|
|
3819
|
+
TimeAdded represents the time at which the taint was added. Added automatically during create or update if not set.
|
|
3820
|
+
"""
|
|
3821
|
+
return pulumi.get(self, "time_added")
|
|
3822
|
+
|
|
3823
|
+
@time_added.setter
|
|
3824
|
+
def time_added(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
3825
|
+
pulumi.set(self, "time_added", value)
|
|
3826
|
+
|
|
3827
|
+
@property
|
|
3828
|
+
@pulumi.getter
|
|
3829
|
+
def value(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
3830
|
+
"""
|
|
3831
|
+
The taint value corresponding to the taint key. Must be a label value.
|
|
3832
|
+
"""
|
|
3833
|
+
return pulumi.get(self, "value")
|
|
3834
|
+
|
|
3835
|
+
@value.setter
|
|
3836
|
+
def value(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
3837
|
+
pulumi.set(self, "value", value)
|
|
3838
|
+
|
|
3839
|
+
|
|
3840
|
+
if not MYPY:
|
|
3841
|
+
class DeviceTolerationPatchArgsDict(TypedDict):
|
|
3842
|
+
"""
|
|
3843
|
+
The ResourceClaim this DeviceToleration is attached to tolerates any taint that matches the triple <key,value,effect> using the matching operator <operator>.
|
|
3844
|
+
"""
|
|
3845
|
+
effect: NotRequired[pulumi.Input[builtins.str]]
|
|
3846
|
+
"""
|
|
3847
|
+
Effect indicates the taint effect to match. Empty means match all taint effects. When specified, allowed values are NoSchedule and NoExecute.
|
|
3848
|
+
"""
|
|
3849
|
+
key: NotRequired[pulumi.Input[builtins.str]]
|
|
3850
|
+
"""
|
|
3851
|
+
Key is the taint key that the toleration applies to. Empty means match all taint keys. If the key is empty, operator must be Exists; this combination means to match all values and all keys. Must be a label name.
|
|
3852
|
+
"""
|
|
3853
|
+
operator: NotRequired[pulumi.Input[builtins.str]]
|
|
3854
|
+
"""
|
|
3855
|
+
Operator represents a key's relationship to the value. Valid operators are Exists and Equal. Defaults to Equal. Exists is equivalent to wildcard for value, so that a ResourceClaim can tolerate all taints of a particular category.
|
|
3856
|
+
"""
|
|
3857
|
+
toleration_seconds: NotRequired[pulumi.Input[builtins.int]]
|
|
3858
|
+
"""
|
|
3859
|
+
TolerationSeconds represents the period of time the toleration (which must be of effect NoExecute, otherwise this field is ignored) tolerates the taint. By default, it is not set, which means tolerate the taint forever (do not evict). Zero and negative values will be treated as 0 (evict immediately) by the system. If larger than zero, the time when the pod needs to be evicted is calculated as <time when taint was adedd> + <toleration seconds>.
|
|
3860
|
+
"""
|
|
3861
|
+
value: NotRequired[pulumi.Input[builtins.str]]
|
|
3862
|
+
"""
|
|
3863
|
+
Value is the taint value the toleration matches to. If the operator is Exists, the value must be empty, otherwise just a regular string. Must be a label value.
|
|
3864
|
+
"""
|
|
3865
|
+
elif False:
|
|
3866
|
+
DeviceTolerationPatchArgsDict: TypeAlias = Mapping[str, Any]
|
|
3867
|
+
|
|
3868
|
+
@pulumi.input_type
|
|
3869
|
+
class DeviceTolerationPatchArgs:
|
|
3870
|
+
def __init__(__self__, *,
|
|
3871
|
+
effect: Optional[pulumi.Input[builtins.str]] = None,
|
|
3872
|
+
key: Optional[pulumi.Input[builtins.str]] = None,
|
|
3873
|
+
operator: Optional[pulumi.Input[builtins.str]] = None,
|
|
3874
|
+
toleration_seconds: Optional[pulumi.Input[builtins.int]] = None,
|
|
3875
|
+
value: Optional[pulumi.Input[builtins.str]] = None):
|
|
3876
|
+
"""
|
|
3877
|
+
The ResourceClaim this DeviceToleration is attached to tolerates any taint that matches the triple <key,value,effect> using the matching operator <operator>.
|
|
3878
|
+
:param pulumi.Input[builtins.str] effect: Effect indicates the taint effect to match. Empty means match all taint effects. When specified, allowed values are NoSchedule and NoExecute.
|
|
3879
|
+
:param pulumi.Input[builtins.str] key: Key is the taint key that the toleration applies to. Empty means match all taint keys. If the key is empty, operator must be Exists; this combination means to match all values and all keys. Must be a label name.
|
|
3880
|
+
:param pulumi.Input[builtins.str] operator: Operator represents a key's relationship to the value. Valid operators are Exists and Equal. Defaults to Equal. Exists is equivalent to wildcard for value, so that a ResourceClaim can tolerate all taints of a particular category.
|
|
3881
|
+
:param pulumi.Input[builtins.int] toleration_seconds: TolerationSeconds represents the period of time the toleration (which must be of effect NoExecute, otherwise this field is ignored) tolerates the taint. By default, it is not set, which means tolerate the taint forever (do not evict). Zero and negative values will be treated as 0 (evict immediately) by the system. If larger than zero, the time when the pod needs to be evicted is calculated as <time when taint was adedd> + <toleration seconds>.
|
|
3882
|
+
:param pulumi.Input[builtins.str] value: Value is the taint value the toleration matches to. If the operator is Exists, the value must be empty, otherwise just a regular string. Must be a label value.
|
|
3883
|
+
"""
|
|
3884
|
+
if effect is not None:
|
|
3885
|
+
pulumi.set(__self__, "effect", effect)
|
|
3886
|
+
if key is not None:
|
|
3887
|
+
pulumi.set(__self__, "key", key)
|
|
3888
|
+
if operator is not None:
|
|
3889
|
+
pulumi.set(__self__, "operator", operator)
|
|
3890
|
+
if toleration_seconds is not None:
|
|
3891
|
+
pulumi.set(__self__, "toleration_seconds", toleration_seconds)
|
|
3892
|
+
if value is not None:
|
|
3893
|
+
pulumi.set(__self__, "value", value)
|
|
3894
|
+
|
|
3895
|
+
@property
|
|
3896
|
+
@pulumi.getter
|
|
3897
|
+
def effect(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
3898
|
+
"""
|
|
3899
|
+
Effect indicates the taint effect to match. Empty means match all taint effects. When specified, allowed values are NoSchedule and NoExecute.
|
|
3900
|
+
"""
|
|
3901
|
+
return pulumi.get(self, "effect")
|
|
3902
|
+
|
|
3903
|
+
@effect.setter
|
|
3904
|
+
def effect(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
3905
|
+
pulumi.set(self, "effect", value)
|
|
3906
|
+
|
|
3907
|
+
@property
|
|
3908
|
+
@pulumi.getter
|
|
3909
|
+
def key(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
3910
|
+
"""
|
|
3911
|
+
Key is the taint key that the toleration applies to. Empty means match all taint keys. If the key is empty, operator must be Exists; this combination means to match all values and all keys. Must be a label name.
|
|
3912
|
+
"""
|
|
3913
|
+
return pulumi.get(self, "key")
|
|
3914
|
+
|
|
3915
|
+
@key.setter
|
|
3916
|
+
def key(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
3917
|
+
pulumi.set(self, "key", value)
|
|
3918
|
+
|
|
3919
|
+
@property
|
|
3920
|
+
@pulumi.getter
|
|
3921
|
+
def operator(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
3922
|
+
"""
|
|
3923
|
+
Operator represents a key's relationship to the value. Valid operators are Exists and Equal. Defaults to Equal. Exists is equivalent to wildcard for value, so that a ResourceClaim can tolerate all taints of a particular category.
|
|
3924
|
+
"""
|
|
3925
|
+
return pulumi.get(self, "operator")
|
|
3926
|
+
|
|
3927
|
+
@operator.setter
|
|
3928
|
+
def operator(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
3929
|
+
pulumi.set(self, "operator", value)
|
|
3930
|
+
|
|
3931
|
+
@property
|
|
3932
|
+
@pulumi.getter(name="tolerationSeconds")
|
|
3933
|
+
def toleration_seconds(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
3934
|
+
"""
|
|
3935
|
+
TolerationSeconds represents the period of time the toleration (which must be of effect NoExecute, otherwise this field is ignored) tolerates the taint. By default, it is not set, which means tolerate the taint forever (do not evict). Zero and negative values will be treated as 0 (evict immediately) by the system. If larger than zero, the time when the pod needs to be evicted is calculated as <time when taint was adedd> + <toleration seconds>.
|
|
3936
|
+
"""
|
|
3937
|
+
return pulumi.get(self, "toleration_seconds")
|
|
3938
|
+
|
|
3939
|
+
@toleration_seconds.setter
|
|
3940
|
+
def toleration_seconds(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
3941
|
+
pulumi.set(self, "toleration_seconds", value)
|
|
3942
|
+
|
|
3943
|
+
@property
|
|
3944
|
+
@pulumi.getter
|
|
3945
|
+
def value(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
3946
|
+
"""
|
|
3947
|
+
Value is the taint value the toleration matches to. If the operator is Exists, the value must be empty, otherwise just a regular string. Must be a label value.
|
|
3948
|
+
"""
|
|
3949
|
+
return pulumi.get(self, "value")
|
|
3950
|
+
|
|
3951
|
+
@value.setter
|
|
3952
|
+
def value(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
3953
|
+
pulumi.set(self, "value", value)
|
|
3954
|
+
|
|
3955
|
+
|
|
3956
|
+
if not MYPY:
|
|
3957
|
+
class DeviceTolerationArgsDict(TypedDict):
|
|
3958
|
+
"""
|
|
3959
|
+
The ResourceClaim this DeviceToleration is attached to tolerates any taint that matches the triple <key,value,effect> using the matching operator <operator>.
|
|
3960
|
+
"""
|
|
3961
|
+
effect: NotRequired[pulumi.Input[builtins.str]]
|
|
3962
|
+
"""
|
|
3963
|
+
Effect indicates the taint effect to match. Empty means match all taint effects. When specified, allowed values are NoSchedule and NoExecute.
|
|
3964
|
+
"""
|
|
3965
|
+
key: NotRequired[pulumi.Input[builtins.str]]
|
|
3966
|
+
"""
|
|
3967
|
+
Key is the taint key that the toleration applies to. Empty means match all taint keys. If the key is empty, operator must be Exists; this combination means to match all values and all keys. Must be a label name.
|
|
3968
|
+
"""
|
|
3969
|
+
operator: NotRequired[pulumi.Input[builtins.str]]
|
|
3970
|
+
"""
|
|
3971
|
+
Operator represents a key's relationship to the value. Valid operators are Exists and Equal. Defaults to Equal. Exists is equivalent to wildcard for value, so that a ResourceClaim can tolerate all taints of a particular category.
|
|
3972
|
+
"""
|
|
3973
|
+
toleration_seconds: NotRequired[pulumi.Input[builtins.int]]
|
|
3974
|
+
"""
|
|
3975
|
+
TolerationSeconds represents the period of time the toleration (which must be of effect NoExecute, otherwise this field is ignored) tolerates the taint. By default, it is not set, which means tolerate the taint forever (do not evict). Zero and negative values will be treated as 0 (evict immediately) by the system. If larger than zero, the time when the pod needs to be evicted is calculated as <time when taint was adedd> + <toleration seconds>.
|
|
3976
|
+
"""
|
|
3977
|
+
value: NotRequired[pulumi.Input[builtins.str]]
|
|
3978
|
+
"""
|
|
3979
|
+
Value is the taint value the toleration matches to. If the operator is Exists, the value must be empty, otherwise just a regular string. Must be a label value.
|
|
3980
|
+
"""
|
|
3981
|
+
elif False:
|
|
3982
|
+
DeviceTolerationArgsDict: TypeAlias = Mapping[str, Any]
|
|
3983
|
+
|
|
3984
|
+
@pulumi.input_type
|
|
3985
|
+
class DeviceTolerationArgs:
|
|
3986
|
+
def __init__(__self__, *,
|
|
3987
|
+
effect: Optional[pulumi.Input[builtins.str]] = None,
|
|
3988
|
+
key: Optional[pulumi.Input[builtins.str]] = None,
|
|
3989
|
+
operator: Optional[pulumi.Input[builtins.str]] = None,
|
|
3990
|
+
toleration_seconds: Optional[pulumi.Input[builtins.int]] = None,
|
|
3991
|
+
value: Optional[pulumi.Input[builtins.str]] = None):
|
|
3992
|
+
"""
|
|
3993
|
+
The ResourceClaim this DeviceToleration is attached to tolerates any taint that matches the triple <key,value,effect> using the matching operator <operator>.
|
|
3994
|
+
:param pulumi.Input[builtins.str] effect: Effect indicates the taint effect to match. Empty means match all taint effects. When specified, allowed values are NoSchedule and NoExecute.
|
|
3995
|
+
:param pulumi.Input[builtins.str] key: Key is the taint key that the toleration applies to. Empty means match all taint keys. If the key is empty, operator must be Exists; this combination means to match all values and all keys. Must be a label name.
|
|
3996
|
+
:param pulumi.Input[builtins.str] operator: Operator represents a key's relationship to the value. Valid operators are Exists and Equal. Defaults to Equal. Exists is equivalent to wildcard for value, so that a ResourceClaim can tolerate all taints of a particular category.
|
|
3997
|
+
:param pulumi.Input[builtins.int] toleration_seconds: TolerationSeconds represents the period of time the toleration (which must be of effect NoExecute, otherwise this field is ignored) tolerates the taint. By default, it is not set, which means tolerate the taint forever (do not evict). Zero and negative values will be treated as 0 (evict immediately) by the system. If larger than zero, the time when the pod needs to be evicted is calculated as <time when taint was adedd> + <toleration seconds>.
|
|
3998
|
+
:param pulumi.Input[builtins.str] value: Value is the taint value the toleration matches to. If the operator is Exists, the value must be empty, otherwise just a regular string. Must be a label value.
|
|
3999
|
+
"""
|
|
4000
|
+
if effect is not None:
|
|
4001
|
+
pulumi.set(__self__, "effect", effect)
|
|
4002
|
+
if key is not None:
|
|
4003
|
+
pulumi.set(__self__, "key", key)
|
|
4004
|
+
if operator is not None:
|
|
4005
|
+
pulumi.set(__self__, "operator", operator)
|
|
4006
|
+
if toleration_seconds is not None:
|
|
4007
|
+
pulumi.set(__self__, "toleration_seconds", toleration_seconds)
|
|
4008
|
+
if value is not None:
|
|
4009
|
+
pulumi.set(__self__, "value", value)
|
|
4010
|
+
|
|
4011
|
+
@property
|
|
4012
|
+
@pulumi.getter
|
|
4013
|
+
def effect(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
4014
|
+
"""
|
|
4015
|
+
Effect indicates the taint effect to match. Empty means match all taint effects. When specified, allowed values are NoSchedule and NoExecute.
|
|
4016
|
+
"""
|
|
4017
|
+
return pulumi.get(self, "effect")
|
|
4018
|
+
|
|
4019
|
+
@effect.setter
|
|
4020
|
+
def effect(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
4021
|
+
pulumi.set(self, "effect", value)
|
|
4022
|
+
|
|
4023
|
+
@property
|
|
4024
|
+
@pulumi.getter
|
|
4025
|
+
def key(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
4026
|
+
"""
|
|
4027
|
+
Key is the taint key that the toleration applies to. Empty means match all taint keys. If the key is empty, operator must be Exists; this combination means to match all values and all keys. Must be a label name.
|
|
4028
|
+
"""
|
|
4029
|
+
return pulumi.get(self, "key")
|
|
4030
|
+
|
|
4031
|
+
@key.setter
|
|
4032
|
+
def key(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
4033
|
+
pulumi.set(self, "key", value)
|
|
4034
|
+
|
|
4035
|
+
@property
|
|
4036
|
+
@pulumi.getter
|
|
4037
|
+
def operator(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
4038
|
+
"""
|
|
4039
|
+
Operator represents a key's relationship to the value. Valid operators are Exists and Equal. Defaults to Equal. Exists is equivalent to wildcard for value, so that a ResourceClaim can tolerate all taints of a particular category.
|
|
4040
|
+
"""
|
|
4041
|
+
return pulumi.get(self, "operator")
|
|
4042
|
+
|
|
4043
|
+
@operator.setter
|
|
4044
|
+
def operator(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
4045
|
+
pulumi.set(self, "operator", value)
|
|
4046
|
+
|
|
4047
|
+
@property
|
|
4048
|
+
@pulumi.getter(name="tolerationSeconds")
|
|
4049
|
+
def toleration_seconds(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
4050
|
+
"""
|
|
4051
|
+
TolerationSeconds represents the period of time the toleration (which must be of effect NoExecute, otherwise this field is ignored) tolerates the taint. By default, it is not set, which means tolerate the taint forever (do not evict). Zero and negative values will be treated as 0 (evict immediately) by the system. If larger than zero, the time when the pod needs to be evicted is calculated as <time when taint was adedd> + <toleration seconds>.
|
|
4052
|
+
"""
|
|
4053
|
+
return pulumi.get(self, "toleration_seconds")
|
|
4054
|
+
|
|
4055
|
+
@toleration_seconds.setter
|
|
4056
|
+
def toleration_seconds(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
4057
|
+
pulumi.set(self, "toleration_seconds", value)
|
|
4058
|
+
|
|
4059
|
+
@property
|
|
4060
|
+
@pulumi.getter
|
|
4061
|
+
def value(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
4062
|
+
"""
|
|
4063
|
+
Value is the taint value the toleration matches to. If the operator is Exists, the value must be empty, otherwise just a regular string. Must be a label value.
|
|
4064
|
+
"""
|
|
4065
|
+
return pulumi.get(self, "value")
|
|
4066
|
+
|
|
4067
|
+
@value.setter
|
|
4068
|
+
def value(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
4069
|
+
pulumi.set(self, "value", value)
|
|
2324
4070
|
|
|
2325
4071
|
|
|
2326
4072
|
if not MYPY:
|
|
@@ -2398,6 +4144,8 @@ if not MYPY:
|
|
|
2398
4144
|
ips: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
|
|
2399
4145
|
"""
|
|
2400
4146
|
IPs lists the network addresses assigned to the device's network interface. This can include both IPv4 and IPv6 addresses. The IPs are in the CIDR notation, which includes both the address and the associated subnet mask. e.g.: "192.0.2.5/24" for IPv4 and "2001:db8::5/64" for IPv6.
|
|
4147
|
+
|
|
4148
|
+
Must not contain more than 16 entries.
|
|
2401
4149
|
"""
|
|
2402
4150
|
elif False:
|
|
2403
4151
|
NetworkDeviceDataArgsDict: TypeAlias = Mapping[str, Any]
|
|
@@ -2417,6 +4165,8 @@ class NetworkDeviceDataArgs:
|
|
|
2417
4165
|
|
|
2418
4166
|
Must not be longer than 256 characters.
|
|
2419
4167
|
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] ips: IPs lists the network addresses assigned to the device's network interface. This can include both IPv4 and IPv6 addresses. The IPs are in the CIDR notation, which includes both the address and the associated subnet mask. e.g.: "192.0.2.5/24" for IPv4 and "2001:db8::5/64" for IPv6.
|
|
4168
|
+
|
|
4169
|
+
Must not contain more than 16 entries.
|
|
2420
4170
|
"""
|
|
2421
4171
|
if hardware_address is not None:
|
|
2422
4172
|
pulumi.set(__self__, "hardware_address", hardware_address)
|
|
@@ -2458,6 +4208,8 @@ class NetworkDeviceDataArgs:
|
|
|
2458
4208
|
def ips(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
2459
4209
|
"""
|
|
2460
4210
|
IPs lists the network addresses assigned to the device's network interface. This can include both IPv4 and IPv6 addresses. The IPs are in the CIDR notation, which includes both the address and the associated subnet mask. e.g.: "192.0.2.5/24" for IPv4 and "2001:db8::5/64" for IPv6.
|
|
4211
|
+
|
|
4212
|
+
Must not contain more than 16 entries.
|
|
2461
4213
|
"""
|
|
2462
4214
|
return pulumi.get(self, "ips")
|
|
2463
4215
|
|
|
@@ -2798,7 +4550,7 @@ if not MYPY:
|
|
|
2798
4550
|
|
|
2799
4551
|
Both schedulers try to add their pod to the claim.status.reservedFor field, but only the update that reaches the API server first gets stored. The other one fails with an error and the scheduler which issued it knows that it must put the pod back into the queue, waiting for the ResourceClaim to become usable again.
|
|
2800
4552
|
|
|
2801
|
-
There can be at most
|
|
4553
|
+
There can be at most 256 such reservations. This may get increased in the future, but not reduced.
|
|
2802
4554
|
"""
|
|
2803
4555
|
elif False:
|
|
2804
4556
|
ResourceClaimStatusArgsDict: TypeAlias = Mapping[str, Any]
|
|
@@ -2819,7 +4571,7 @@ class ResourceClaimStatusArgs:
|
|
|
2819
4571
|
|
|
2820
4572
|
Both schedulers try to add their pod to the claim.status.reservedFor field, but only the update that reaches the API server first gets stored. The other one fails with an error and the scheduler which issued it knows that it must put the pod back into the queue, waiting for the ResourceClaim to become usable again.
|
|
2821
4573
|
|
|
2822
|
-
There can be at most
|
|
4574
|
+
There can be at most 256 such reservations. This may get increased in the future, but not reduced.
|
|
2823
4575
|
"""
|
|
2824
4576
|
if allocation is not None:
|
|
2825
4577
|
pulumi.set(__self__, "allocation", allocation)
|
|
@@ -2862,7 +4614,7 @@ class ResourceClaimStatusArgs:
|
|
|
2862
4614
|
|
|
2863
4615
|
Both schedulers try to add their pod to the claim.status.reservedFor field, but only the update that reaches the API server first gets stored. The other one fails with an error and the scheduler which issued it knows that it must put the pod back into the queue, waiting for the ResourceClaim to become usable again.
|
|
2864
4616
|
|
|
2865
|
-
There can be at most
|
|
4617
|
+
There can be at most 256 such reservations. This may get increased in the future, but not reduced.
|
|
2866
4618
|
"""
|
|
2867
4619
|
return pulumi.get(self, "reserved_for")
|
|
2868
4620
|
|
|
@@ -3400,7 +5152,7 @@ if not MYPY:
|
|
|
3400
5152
|
"""
|
|
3401
5153
|
AllNodes indicates that all nodes have access to the resources in the pool.
|
|
3402
5154
|
|
|
3403
|
-
Exactly one of NodeName, NodeSelector and
|
|
5155
|
+
Exactly one of NodeName, NodeSelector, AllNodes, and PerDeviceNodeSelection must be set.
|
|
3404
5156
|
"""
|
|
3405
5157
|
devices: NotRequired[pulumi.Input[Sequence[pulumi.Input['DevicePatchArgsDict']]]]
|
|
3406
5158
|
"""
|
|
@@ -3420,7 +5172,7 @@ if not MYPY:
|
|
|
3420
5172
|
|
|
3421
5173
|
This field can be used to limit access from nodes to ResourceSlices with the same node name. It also indicates to autoscalers that adding new nodes of the same type as some old node might also make new resources available.
|
|
3422
5174
|
|
|
3423
|
-
Exactly one of NodeName, NodeSelector and
|
|
5175
|
+
Exactly one of NodeName, NodeSelector, AllNodes, and PerDeviceNodeSelection must be set. This field is immutable.
|
|
3424
5176
|
"""
|
|
3425
5177
|
node_selector: NotRequired[pulumi.Input['_core.v1.NodeSelectorPatchArgsDict']]
|
|
3426
5178
|
"""
|
|
@@ -3428,12 +5180,26 @@ if not MYPY:
|
|
|
3428
5180
|
|
|
3429
5181
|
Must use exactly one term.
|
|
3430
5182
|
|
|
3431
|
-
Exactly one of NodeName, NodeSelector and
|
|
5183
|
+
Exactly one of NodeName, NodeSelector, AllNodes, and PerDeviceNodeSelection must be set.
|
|
5184
|
+
"""
|
|
5185
|
+
per_device_node_selection: NotRequired[pulumi.Input[builtins.bool]]
|
|
5186
|
+
"""
|
|
5187
|
+
PerDeviceNodeSelection defines whether the access from nodes to resources in the pool is set on the ResourceSlice level or on each device. If it is set to true, every device defined the ResourceSlice must specify this individually.
|
|
5188
|
+
|
|
5189
|
+
Exactly one of NodeName, NodeSelector, AllNodes, and PerDeviceNodeSelection must be set.
|
|
3432
5190
|
"""
|
|
3433
5191
|
pool: NotRequired[pulumi.Input['ResourcePoolPatchArgsDict']]
|
|
3434
5192
|
"""
|
|
3435
5193
|
Pool describes the pool that this ResourceSlice belongs to.
|
|
3436
5194
|
"""
|
|
5195
|
+
shared_counters: NotRequired[pulumi.Input[Sequence[pulumi.Input['CounterSetPatchArgsDict']]]]
|
|
5196
|
+
"""
|
|
5197
|
+
SharedCounters defines a list of counter sets, each of which has a name and a list of counters available.
|
|
5198
|
+
|
|
5199
|
+
The names of the SharedCounters must be unique in the ResourceSlice.
|
|
5200
|
+
|
|
5201
|
+
The maximum number of SharedCounters is 32.
|
|
5202
|
+
"""
|
|
3437
5203
|
elif False:
|
|
3438
5204
|
ResourceSliceSpecPatchArgsDict: TypeAlias = Mapping[str, Any]
|
|
3439
5205
|
|
|
@@ -3445,12 +5211,14 @@ class ResourceSliceSpecPatchArgs:
|
|
|
3445
5211
|
driver: Optional[pulumi.Input[builtins.str]] = None,
|
|
3446
5212
|
node_name: Optional[pulumi.Input[builtins.str]] = None,
|
|
3447
5213
|
node_selector: Optional[pulumi.Input['_core.v1.NodeSelectorPatchArgs']] = None,
|
|
3448
|
-
|
|
5214
|
+
per_device_node_selection: Optional[pulumi.Input[builtins.bool]] = None,
|
|
5215
|
+
pool: Optional[pulumi.Input['ResourcePoolPatchArgs']] = None,
|
|
5216
|
+
shared_counters: Optional[pulumi.Input[Sequence[pulumi.Input['CounterSetPatchArgs']]]] = None):
|
|
3449
5217
|
"""
|
|
3450
5218
|
ResourceSliceSpec contains the information published by the driver in one ResourceSlice.
|
|
3451
5219
|
:param pulumi.Input[builtins.bool] all_nodes: AllNodes indicates that all nodes have access to the resources in the pool.
|
|
3452
5220
|
|
|
3453
|
-
Exactly one of NodeName, NodeSelector and
|
|
5221
|
+
Exactly one of NodeName, NodeSelector, AllNodes, and PerDeviceNodeSelection must be set.
|
|
3454
5222
|
:param pulumi.Input[Sequence[pulumi.Input['DevicePatchArgs']]] devices: Devices lists some or all of the devices in this pool.
|
|
3455
5223
|
|
|
3456
5224
|
Must not have more than 128 entries.
|
|
@@ -3461,13 +5229,21 @@ class ResourceSliceSpecPatchArgs:
|
|
|
3461
5229
|
|
|
3462
5230
|
This field can be used to limit access from nodes to ResourceSlices with the same node name. It also indicates to autoscalers that adding new nodes of the same type as some old node might also make new resources available.
|
|
3463
5231
|
|
|
3464
|
-
Exactly one of NodeName, NodeSelector and
|
|
5232
|
+
Exactly one of NodeName, NodeSelector, AllNodes, and PerDeviceNodeSelection must be set. This field is immutable.
|
|
3465
5233
|
:param pulumi.Input['_core.v1.NodeSelectorPatchArgs'] node_selector: NodeSelector defines which nodes have access to the resources in the pool, when that pool is not limited to a single node.
|
|
3466
5234
|
|
|
3467
5235
|
Must use exactly one term.
|
|
3468
5236
|
|
|
3469
|
-
Exactly one of NodeName, NodeSelector and
|
|
5237
|
+
Exactly one of NodeName, NodeSelector, AllNodes, and PerDeviceNodeSelection must be set.
|
|
5238
|
+
:param pulumi.Input[builtins.bool] per_device_node_selection: PerDeviceNodeSelection defines whether the access from nodes to resources in the pool is set on the ResourceSlice level or on each device. If it is set to true, every device defined the ResourceSlice must specify this individually.
|
|
5239
|
+
|
|
5240
|
+
Exactly one of NodeName, NodeSelector, AllNodes, and PerDeviceNodeSelection must be set.
|
|
3470
5241
|
:param pulumi.Input['ResourcePoolPatchArgs'] pool: Pool describes the pool that this ResourceSlice belongs to.
|
|
5242
|
+
:param pulumi.Input[Sequence[pulumi.Input['CounterSetPatchArgs']]] shared_counters: SharedCounters defines a list of counter sets, each of which has a name and a list of counters available.
|
|
5243
|
+
|
|
5244
|
+
The names of the SharedCounters must be unique in the ResourceSlice.
|
|
5245
|
+
|
|
5246
|
+
The maximum number of SharedCounters is 32.
|
|
3471
5247
|
"""
|
|
3472
5248
|
if all_nodes is not None:
|
|
3473
5249
|
pulumi.set(__self__, "all_nodes", all_nodes)
|
|
@@ -3479,8 +5255,12 @@ class ResourceSliceSpecPatchArgs:
|
|
|
3479
5255
|
pulumi.set(__self__, "node_name", node_name)
|
|
3480
5256
|
if node_selector is not None:
|
|
3481
5257
|
pulumi.set(__self__, "node_selector", node_selector)
|
|
5258
|
+
if per_device_node_selection is not None:
|
|
5259
|
+
pulumi.set(__self__, "per_device_node_selection", per_device_node_selection)
|
|
3482
5260
|
if pool is not None:
|
|
3483
5261
|
pulumi.set(__self__, "pool", pool)
|
|
5262
|
+
if shared_counters is not None:
|
|
5263
|
+
pulumi.set(__self__, "shared_counters", shared_counters)
|
|
3484
5264
|
|
|
3485
5265
|
@property
|
|
3486
5266
|
@pulumi.getter(name="allNodes")
|
|
@@ -3488,7 +5268,7 @@ class ResourceSliceSpecPatchArgs:
|
|
|
3488
5268
|
"""
|
|
3489
5269
|
AllNodes indicates that all nodes have access to the resources in the pool.
|
|
3490
5270
|
|
|
3491
|
-
Exactly one of NodeName, NodeSelector and
|
|
5271
|
+
Exactly one of NodeName, NodeSelector, AllNodes, and PerDeviceNodeSelection must be set.
|
|
3492
5272
|
"""
|
|
3493
5273
|
return pulumi.get(self, "all_nodes")
|
|
3494
5274
|
|
|
@@ -3532,7 +5312,7 @@ class ResourceSliceSpecPatchArgs:
|
|
|
3532
5312
|
|
|
3533
5313
|
This field can be used to limit access from nodes to ResourceSlices with the same node name. It also indicates to autoscalers that adding new nodes of the same type as some old node might also make new resources available.
|
|
3534
5314
|
|
|
3535
|
-
Exactly one of NodeName, NodeSelector and
|
|
5315
|
+
Exactly one of NodeName, NodeSelector, AllNodes, and PerDeviceNodeSelection must be set. This field is immutable.
|
|
3536
5316
|
"""
|
|
3537
5317
|
return pulumi.get(self, "node_name")
|
|
3538
5318
|
|
|
@@ -3548,7 +5328,7 @@ class ResourceSliceSpecPatchArgs:
|
|
|
3548
5328
|
|
|
3549
5329
|
Must use exactly one term.
|
|
3550
5330
|
|
|
3551
|
-
Exactly one of NodeName, NodeSelector and
|
|
5331
|
+
Exactly one of NodeName, NodeSelector, AllNodes, and PerDeviceNodeSelection must be set.
|
|
3552
5332
|
"""
|
|
3553
5333
|
return pulumi.get(self, "node_selector")
|
|
3554
5334
|
|
|
@@ -3556,6 +5336,20 @@ class ResourceSliceSpecPatchArgs:
|
|
|
3556
5336
|
def node_selector(self, value: Optional[pulumi.Input['_core.v1.NodeSelectorPatchArgs']]):
|
|
3557
5337
|
pulumi.set(self, "node_selector", value)
|
|
3558
5338
|
|
|
5339
|
+
@property
|
|
5340
|
+
@pulumi.getter(name="perDeviceNodeSelection")
|
|
5341
|
+
def per_device_node_selection(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
5342
|
+
"""
|
|
5343
|
+
PerDeviceNodeSelection defines whether the access from nodes to resources in the pool is set on the ResourceSlice level or on each device. If it is set to true, every device defined the ResourceSlice must specify this individually.
|
|
5344
|
+
|
|
5345
|
+
Exactly one of NodeName, NodeSelector, AllNodes, and PerDeviceNodeSelection must be set.
|
|
5346
|
+
"""
|
|
5347
|
+
return pulumi.get(self, "per_device_node_selection")
|
|
5348
|
+
|
|
5349
|
+
@per_device_node_selection.setter
|
|
5350
|
+
def per_device_node_selection(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
5351
|
+
pulumi.set(self, "per_device_node_selection", value)
|
|
5352
|
+
|
|
3559
5353
|
@property
|
|
3560
5354
|
@pulumi.getter
|
|
3561
5355
|
def pool(self) -> Optional[pulumi.Input['ResourcePoolPatchArgs']]:
|
|
@@ -3568,6 +5362,22 @@ class ResourceSliceSpecPatchArgs:
|
|
|
3568
5362
|
def pool(self, value: Optional[pulumi.Input['ResourcePoolPatchArgs']]):
|
|
3569
5363
|
pulumi.set(self, "pool", value)
|
|
3570
5364
|
|
|
5365
|
+
@property
|
|
5366
|
+
@pulumi.getter(name="sharedCounters")
|
|
5367
|
+
def shared_counters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['CounterSetPatchArgs']]]]:
|
|
5368
|
+
"""
|
|
5369
|
+
SharedCounters defines a list of counter sets, each of which has a name and a list of counters available.
|
|
5370
|
+
|
|
5371
|
+
The names of the SharedCounters must be unique in the ResourceSlice.
|
|
5372
|
+
|
|
5373
|
+
The maximum number of SharedCounters is 32.
|
|
5374
|
+
"""
|
|
5375
|
+
return pulumi.get(self, "shared_counters")
|
|
5376
|
+
|
|
5377
|
+
@shared_counters.setter
|
|
5378
|
+
def shared_counters(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['CounterSetPatchArgs']]]]):
|
|
5379
|
+
pulumi.set(self, "shared_counters", value)
|
|
5380
|
+
|
|
3571
5381
|
|
|
3572
5382
|
if not MYPY:
|
|
3573
5383
|
class ResourceSliceSpecArgsDict(TypedDict):
|
|
@@ -3588,7 +5398,7 @@ if not MYPY:
|
|
|
3588
5398
|
"""
|
|
3589
5399
|
AllNodes indicates that all nodes have access to the resources in the pool.
|
|
3590
5400
|
|
|
3591
|
-
Exactly one of NodeName, NodeSelector and
|
|
5401
|
+
Exactly one of NodeName, NodeSelector, AllNodes, and PerDeviceNodeSelection must be set.
|
|
3592
5402
|
"""
|
|
3593
5403
|
devices: NotRequired[pulumi.Input[Sequence[pulumi.Input['DeviceArgsDict']]]]
|
|
3594
5404
|
"""
|
|
@@ -3602,7 +5412,7 @@ if not MYPY:
|
|
|
3602
5412
|
|
|
3603
5413
|
This field can be used to limit access from nodes to ResourceSlices with the same node name. It also indicates to autoscalers that adding new nodes of the same type as some old node might also make new resources available.
|
|
3604
5414
|
|
|
3605
|
-
Exactly one of NodeName, NodeSelector and
|
|
5415
|
+
Exactly one of NodeName, NodeSelector, AllNodes, and PerDeviceNodeSelection must be set. This field is immutable.
|
|
3606
5416
|
"""
|
|
3607
5417
|
node_selector: NotRequired[pulumi.Input['_core.v1.NodeSelectorArgsDict']]
|
|
3608
5418
|
"""
|
|
@@ -3610,7 +5420,21 @@ if not MYPY:
|
|
|
3610
5420
|
|
|
3611
5421
|
Must use exactly one term.
|
|
3612
5422
|
|
|
3613
|
-
Exactly one of NodeName, NodeSelector and
|
|
5423
|
+
Exactly one of NodeName, NodeSelector, AllNodes, and PerDeviceNodeSelection must be set.
|
|
5424
|
+
"""
|
|
5425
|
+
per_device_node_selection: NotRequired[pulumi.Input[builtins.bool]]
|
|
5426
|
+
"""
|
|
5427
|
+
PerDeviceNodeSelection defines whether the access from nodes to resources in the pool is set on the ResourceSlice level or on each device. If it is set to true, every device defined the ResourceSlice must specify this individually.
|
|
5428
|
+
|
|
5429
|
+
Exactly one of NodeName, NodeSelector, AllNodes, and PerDeviceNodeSelection must be set.
|
|
5430
|
+
"""
|
|
5431
|
+
shared_counters: NotRequired[pulumi.Input[Sequence[pulumi.Input['CounterSetArgsDict']]]]
|
|
5432
|
+
"""
|
|
5433
|
+
SharedCounters defines a list of counter sets, each of which has a name and a list of counters available.
|
|
5434
|
+
|
|
5435
|
+
The names of the SharedCounters must be unique in the ResourceSlice.
|
|
5436
|
+
|
|
5437
|
+
The maximum number of SharedCounters is 32.
|
|
3614
5438
|
"""
|
|
3615
5439
|
elif False:
|
|
3616
5440
|
ResourceSliceSpecArgsDict: TypeAlias = Mapping[str, Any]
|
|
@@ -3623,7 +5447,9 @@ class ResourceSliceSpecArgs:
|
|
|
3623
5447
|
all_nodes: Optional[pulumi.Input[builtins.bool]] = None,
|
|
3624
5448
|
devices: Optional[pulumi.Input[Sequence[pulumi.Input['DeviceArgs']]]] = None,
|
|
3625
5449
|
node_name: Optional[pulumi.Input[builtins.str]] = None,
|
|
3626
|
-
node_selector: Optional[pulumi.Input['_core.v1.NodeSelectorArgs']] = None
|
|
5450
|
+
node_selector: Optional[pulumi.Input['_core.v1.NodeSelectorArgs']] = None,
|
|
5451
|
+
per_device_node_selection: Optional[pulumi.Input[builtins.bool]] = None,
|
|
5452
|
+
shared_counters: Optional[pulumi.Input[Sequence[pulumi.Input['CounterSetArgs']]]] = None):
|
|
3627
5453
|
"""
|
|
3628
5454
|
ResourceSliceSpec contains the information published by the driver in one ResourceSlice.
|
|
3629
5455
|
:param pulumi.Input[builtins.str] driver: Driver identifies the DRA driver providing the capacity information. A field selector can be used to list only ResourceSlice objects with a certain driver name.
|
|
@@ -3632,7 +5458,7 @@ class ResourceSliceSpecArgs:
|
|
|
3632
5458
|
:param pulumi.Input['ResourcePoolArgs'] pool: Pool describes the pool that this ResourceSlice belongs to.
|
|
3633
5459
|
:param pulumi.Input[builtins.bool] all_nodes: AllNodes indicates that all nodes have access to the resources in the pool.
|
|
3634
5460
|
|
|
3635
|
-
Exactly one of NodeName, NodeSelector and
|
|
5461
|
+
Exactly one of NodeName, NodeSelector, AllNodes, and PerDeviceNodeSelection must be set.
|
|
3636
5462
|
:param pulumi.Input[Sequence[pulumi.Input['DeviceArgs']]] devices: Devices lists some or all of the devices in this pool.
|
|
3637
5463
|
|
|
3638
5464
|
Must not have more than 128 entries.
|
|
@@ -3640,12 +5466,20 @@ class ResourceSliceSpecArgs:
|
|
|
3640
5466
|
|
|
3641
5467
|
This field can be used to limit access from nodes to ResourceSlices with the same node name. It also indicates to autoscalers that adding new nodes of the same type as some old node might also make new resources available.
|
|
3642
5468
|
|
|
3643
|
-
Exactly one of NodeName, NodeSelector and
|
|
5469
|
+
Exactly one of NodeName, NodeSelector, AllNodes, and PerDeviceNodeSelection must be set. This field is immutable.
|
|
3644
5470
|
:param pulumi.Input['_core.v1.NodeSelectorArgs'] node_selector: NodeSelector defines which nodes have access to the resources in the pool, when that pool is not limited to a single node.
|
|
3645
5471
|
|
|
3646
5472
|
Must use exactly one term.
|
|
3647
5473
|
|
|
3648
|
-
Exactly one of NodeName, NodeSelector and
|
|
5474
|
+
Exactly one of NodeName, NodeSelector, AllNodes, and PerDeviceNodeSelection must be set.
|
|
5475
|
+
:param pulumi.Input[builtins.bool] per_device_node_selection: PerDeviceNodeSelection defines whether the access from nodes to resources in the pool is set on the ResourceSlice level or on each device. If it is set to true, every device defined the ResourceSlice must specify this individually.
|
|
5476
|
+
|
|
5477
|
+
Exactly one of NodeName, NodeSelector, AllNodes, and PerDeviceNodeSelection must be set.
|
|
5478
|
+
:param pulumi.Input[Sequence[pulumi.Input['CounterSetArgs']]] shared_counters: SharedCounters defines a list of counter sets, each of which has a name and a list of counters available.
|
|
5479
|
+
|
|
5480
|
+
The names of the SharedCounters must be unique in the ResourceSlice.
|
|
5481
|
+
|
|
5482
|
+
The maximum number of SharedCounters is 32.
|
|
3649
5483
|
"""
|
|
3650
5484
|
pulumi.set(__self__, "driver", driver)
|
|
3651
5485
|
pulumi.set(__self__, "pool", pool)
|
|
@@ -3657,6 +5491,10 @@ class ResourceSliceSpecArgs:
|
|
|
3657
5491
|
pulumi.set(__self__, "node_name", node_name)
|
|
3658
5492
|
if node_selector is not None:
|
|
3659
5493
|
pulumi.set(__self__, "node_selector", node_selector)
|
|
5494
|
+
if per_device_node_selection is not None:
|
|
5495
|
+
pulumi.set(__self__, "per_device_node_selection", per_device_node_selection)
|
|
5496
|
+
if shared_counters is not None:
|
|
5497
|
+
pulumi.set(__self__, "shared_counters", shared_counters)
|
|
3660
5498
|
|
|
3661
5499
|
@property
|
|
3662
5500
|
@pulumi.getter
|
|
@@ -3690,7 +5528,7 @@ class ResourceSliceSpecArgs:
|
|
|
3690
5528
|
"""
|
|
3691
5529
|
AllNodes indicates that all nodes have access to the resources in the pool.
|
|
3692
5530
|
|
|
3693
|
-
Exactly one of NodeName, NodeSelector and
|
|
5531
|
+
Exactly one of NodeName, NodeSelector, AllNodes, and PerDeviceNodeSelection must be set.
|
|
3694
5532
|
"""
|
|
3695
5533
|
return pulumi.get(self, "all_nodes")
|
|
3696
5534
|
|
|
@@ -3720,7 +5558,7 @@ class ResourceSliceSpecArgs:
|
|
|
3720
5558
|
|
|
3721
5559
|
This field can be used to limit access from nodes to ResourceSlices with the same node name. It also indicates to autoscalers that adding new nodes of the same type as some old node might also make new resources available.
|
|
3722
5560
|
|
|
3723
|
-
Exactly one of NodeName, NodeSelector and
|
|
5561
|
+
Exactly one of NodeName, NodeSelector, AllNodes, and PerDeviceNodeSelection must be set. This field is immutable.
|
|
3724
5562
|
"""
|
|
3725
5563
|
return pulumi.get(self, "node_name")
|
|
3726
5564
|
|
|
@@ -3736,7 +5574,7 @@ class ResourceSliceSpecArgs:
|
|
|
3736
5574
|
|
|
3737
5575
|
Must use exactly one term.
|
|
3738
5576
|
|
|
3739
|
-
Exactly one of NodeName, NodeSelector and
|
|
5577
|
+
Exactly one of NodeName, NodeSelector, AllNodes, and PerDeviceNodeSelection must be set.
|
|
3740
5578
|
"""
|
|
3741
5579
|
return pulumi.get(self, "node_selector")
|
|
3742
5580
|
|
|
@@ -3744,6 +5582,36 @@ class ResourceSliceSpecArgs:
|
|
|
3744
5582
|
def node_selector(self, value: Optional[pulumi.Input['_core.v1.NodeSelectorArgs']]):
|
|
3745
5583
|
pulumi.set(self, "node_selector", value)
|
|
3746
5584
|
|
|
5585
|
+
@property
|
|
5586
|
+
@pulumi.getter(name="perDeviceNodeSelection")
|
|
5587
|
+
def per_device_node_selection(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
5588
|
+
"""
|
|
5589
|
+
PerDeviceNodeSelection defines whether the access from nodes to resources in the pool is set on the ResourceSlice level or on each device. If it is set to true, every device defined the ResourceSlice must specify this individually.
|
|
5590
|
+
|
|
5591
|
+
Exactly one of NodeName, NodeSelector, AllNodes, and PerDeviceNodeSelection must be set.
|
|
5592
|
+
"""
|
|
5593
|
+
return pulumi.get(self, "per_device_node_selection")
|
|
5594
|
+
|
|
5595
|
+
@per_device_node_selection.setter
|
|
5596
|
+
def per_device_node_selection(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
5597
|
+
pulumi.set(self, "per_device_node_selection", value)
|
|
5598
|
+
|
|
5599
|
+
@property
|
|
5600
|
+
@pulumi.getter(name="sharedCounters")
|
|
5601
|
+
def shared_counters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['CounterSetArgs']]]]:
|
|
5602
|
+
"""
|
|
5603
|
+
SharedCounters defines a list of counter sets, each of which has a name and a list of counters available.
|
|
5604
|
+
|
|
5605
|
+
The names of the SharedCounters must be unique in the ResourceSlice.
|
|
5606
|
+
|
|
5607
|
+
The maximum number of SharedCounters is 32.
|
|
5608
|
+
"""
|
|
5609
|
+
return pulumi.get(self, "shared_counters")
|
|
5610
|
+
|
|
5611
|
+
@shared_counters.setter
|
|
5612
|
+
def shared_counters(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['CounterSetArgs']]]]):
|
|
5613
|
+
pulumi.set(self, "shared_counters", value)
|
|
5614
|
+
|
|
3747
5615
|
|
|
3748
5616
|
if not MYPY:
|
|
3749
5617
|
class ResourceSliceArgsDict(TypedDict):
|