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',
|
|
@@ -58,6 +64,10 @@ __all__ = [
|
|
|
58
64
|
'DeviceConstraintPatchArgsDict',
|
|
59
65
|
'DeviceConstraintArgs',
|
|
60
66
|
'DeviceConstraintArgsDict',
|
|
67
|
+
'DeviceCounterConsumptionPatchArgs',
|
|
68
|
+
'DeviceCounterConsumptionPatchArgsDict',
|
|
69
|
+
'DeviceCounterConsumptionArgs',
|
|
70
|
+
'DeviceCounterConsumptionArgsDict',
|
|
61
71
|
'DevicePatchArgs',
|
|
62
72
|
'DevicePatchArgsDict',
|
|
63
73
|
'DeviceRequestAllocationResultArgs',
|
|
@@ -70,6 +80,28 @@ __all__ = [
|
|
|
70
80
|
'DeviceSelectorPatchArgsDict',
|
|
71
81
|
'DeviceSelectorArgs',
|
|
72
82
|
'DeviceSelectorArgsDict',
|
|
83
|
+
'DeviceSubRequestPatchArgs',
|
|
84
|
+
'DeviceSubRequestPatchArgsDict',
|
|
85
|
+
'DeviceSubRequestArgs',
|
|
86
|
+
'DeviceSubRequestArgsDict',
|
|
87
|
+
'DeviceTaintPatchArgs',
|
|
88
|
+
'DeviceTaintPatchArgsDict',
|
|
89
|
+
'DeviceTaintRuleSpecPatchArgs',
|
|
90
|
+
'DeviceTaintRuleSpecPatchArgsDict',
|
|
91
|
+
'DeviceTaintRuleSpecArgs',
|
|
92
|
+
'DeviceTaintRuleSpecArgsDict',
|
|
93
|
+
'DeviceTaintRuleArgs',
|
|
94
|
+
'DeviceTaintRuleArgsDict',
|
|
95
|
+
'DeviceTaintSelectorPatchArgs',
|
|
96
|
+
'DeviceTaintSelectorPatchArgsDict',
|
|
97
|
+
'DeviceTaintSelectorArgs',
|
|
98
|
+
'DeviceTaintSelectorArgsDict',
|
|
99
|
+
'DeviceTaintArgs',
|
|
100
|
+
'DeviceTaintArgsDict',
|
|
101
|
+
'DeviceTolerationPatchArgs',
|
|
102
|
+
'DeviceTolerationPatchArgsDict',
|
|
103
|
+
'DeviceTolerationArgs',
|
|
104
|
+
'DeviceTolerationArgsDict',
|
|
73
105
|
'DeviceArgs',
|
|
74
106
|
'DeviceArgsDict',
|
|
75
107
|
'NetworkDeviceDataArgs',
|
|
@@ -142,6 +174,8 @@ if not MYPY:
|
|
|
142
174
|
conditions: NotRequired[pulumi.Input[Sequence[pulumi.Input['_meta.v1.ConditionArgsDict']]]]
|
|
143
175
|
"""
|
|
144
176
|
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.
|
|
177
|
+
|
|
178
|
+
Must not contain more than 8 entries.
|
|
145
179
|
"""
|
|
146
180
|
data: NotRequired[Any]
|
|
147
181
|
"""
|
|
@@ -175,6 +209,8 @@ class AllocatedDeviceStatusArgs:
|
|
|
175
209
|
|
|
176
210
|
Must not be longer than 253 characters and may contain one or more DNS sub-domains separated by slashes.
|
|
177
211
|
: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.
|
|
212
|
+
|
|
213
|
+
Must not contain more than 8 entries.
|
|
178
214
|
:param Any data: Data contains arbitrary driver-specific data.
|
|
179
215
|
|
|
180
216
|
The length of the raw data must be smaller or equal to 10 Ki.
|
|
@@ -235,6 +271,8 @@ class AllocatedDeviceStatusArgs:
|
|
|
235
271
|
def conditions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['_meta.v1.ConditionArgs']]]]:
|
|
236
272
|
"""
|
|
237
273
|
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.
|
|
274
|
+
|
|
275
|
+
Must not contain more than 8 entries.
|
|
238
276
|
"""
|
|
239
277
|
return pulumi.get(self, "conditions")
|
|
240
278
|
|
|
@@ -362,6 +400,12 @@ if not MYPY:
|
|
|
362
400
|
"""
|
|
363
401
|
BasicDevice defines one device instance.
|
|
364
402
|
"""
|
|
403
|
+
all_nodes: NotRequired[pulumi.Input[builtins.bool]]
|
|
404
|
+
"""
|
|
405
|
+
AllNodes indicates that all nodes have access to the device.
|
|
406
|
+
|
|
407
|
+
Must only be set if Spec.PerDeviceNodeSelection is set to true. At most one of NodeName, NodeSelector and AllNodes can be set.
|
|
408
|
+
"""
|
|
365
409
|
attributes: NotRequired[pulumi.Input[Mapping[str, pulumi.Input['DeviceAttributeArgsDict']]]]
|
|
366
410
|
"""
|
|
367
411
|
Attributes defines the set of attributes for this device. The name of each attribute must be unique in that set.
|
|
@@ -374,27 +418,103 @@ if not MYPY:
|
|
|
374
418
|
|
|
375
419
|
The maximum number of attributes and capacities combined is 32.
|
|
376
420
|
"""
|
|
421
|
+
consumes_counters: NotRequired[pulumi.Input[Sequence[pulumi.Input['DeviceCounterConsumptionPatchArgsDict']]]]
|
|
422
|
+
"""
|
|
423
|
+
ConsumesCounters defines a list of references to sharedCounters and the set of counters that the device will consume from those counter sets.
|
|
424
|
+
|
|
425
|
+
There can only be a single entry per counterSet.
|
|
426
|
+
|
|
427
|
+
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).
|
|
428
|
+
"""
|
|
429
|
+
node_name: NotRequired[pulumi.Input[builtins.str]]
|
|
430
|
+
"""
|
|
431
|
+
NodeName identifies the node where the device is available.
|
|
432
|
+
|
|
433
|
+
Must only be set if Spec.PerDeviceNodeSelection is set to true. At most one of NodeName, NodeSelector and AllNodes can be set.
|
|
434
|
+
"""
|
|
435
|
+
node_selector: NotRequired[pulumi.Input['_core.v1.NodeSelectorPatchArgsDict']]
|
|
436
|
+
"""
|
|
437
|
+
NodeSelector defines the nodes where the device is available.
|
|
438
|
+
|
|
439
|
+
Must only be set if Spec.PerDeviceNodeSelection is set to true. At most one of NodeName, NodeSelector and AllNodes can be set.
|
|
440
|
+
"""
|
|
441
|
+
taints: NotRequired[pulumi.Input[Sequence[pulumi.Input['DeviceTaintPatchArgsDict']]]]
|
|
442
|
+
"""
|
|
443
|
+
If specified, these are the driver-defined taints.
|
|
444
|
+
|
|
445
|
+
The maximum number of taints is 4.
|
|
446
|
+
|
|
447
|
+
This is an alpha field and requires enabling the DRADeviceTaints feature gate.
|
|
448
|
+
"""
|
|
377
449
|
elif False:
|
|
378
450
|
BasicDevicePatchArgsDict: TypeAlias = Mapping[str, Any]
|
|
379
451
|
|
|
380
452
|
@pulumi.input_type
|
|
381
453
|
class BasicDevicePatchArgs:
|
|
382
454
|
def __init__(__self__, *,
|
|
455
|
+
all_nodes: Optional[pulumi.Input[builtins.bool]] = None,
|
|
383
456
|
attributes: Optional[pulumi.Input[Mapping[str, pulumi.Input['DeviceAttributeArgs']]]] = None,
|
|
384
|
-
capacity: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None
|
|
457
|
+
capacity: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None,
|
|
458
|
+
consumes_counters: Optional[pulumi.Input[Sequence[pulumi.Input['DeviceCounterConsumptionPatchArgs']]]] = None,
|
|
459
|
+
node_name: Optional[pulumi.Input[builtins.str]] = None,
|
|
460
|
+
node_selector: Optional[pulumi.Input['_core.v1.NodeSelectorPatchArgs']] = None,
|
|
461
|
+
taints: Optional[pulumi.Input[Sequence[pulumi.Input['DeviceTaintPatchArgs']]]] = None):
|
|
385
462
|
"""
|
|
386
463
|
BasicDevice defines one device instance.
|
|
464
|
+
:param pulumi.Input[builtins.bool] all_nodes: AllNodes indicates that all nodes have access to the device.
|
|
465
|
+
|
|
466
|
+
Must only be set if Spec.PerDeviceNodeSelection is set to true. At most one of NodeName, NodeSelector and AllNodes can be set.
|
|
387
467
|
: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.
|
|
388
468
|
|
|
389
469
|
The maximum number of attributes and capacities combined is 32.
|
|
390
470
|
:param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] capacity: Capacity defines the set of capacities for this device. The name of each capacity must be unique in that set.
|
|
391
471
|
|
|
392
472
|
The maximum number of attributes and capacities combined is 32.
|
|
473
|
+
: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.
|
|
474
|
+
|
|
475
|
+
There can only be a single entry per counterSet.
|
|
476
|
+
|
|
477
|
+
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).
|
|
478
|
+
:param pulumi.Input[builtins.str] node_name: NodeName identifies the node where the device is available.
|
|
479
|
+
|
|
480
|
+
Must only be set if Spec.PerDeviceNodeSelection is set to true. At most one of NodeName, NodeSelector and AllNodes can be set.
|
|
481
|
+
:param pulumi.Input['_core.v1.NodeSelectorPatchArgs'] node_selector: NodeSelector defines the nodes where the device is available.
|
|
482
|
+
|
|
483
|
+
Must only be set if Spec.PerDeviceNodeSelection is set to true. At most one of NodeName, NodeSelector and AllNodes can be set.
|
|
484
|
+
:param pulumi.Input[Sequence[pulumi.Input['DeviceTaintPatchArgs']]] taints: If specified, these are the driver-defined taints.
|
|
485
|
+
|
|
486
|
+
The maximum number of taints is 4.
|
|
487
|
+
|
|
488
|
+
This is an alpha field and requires enabling the DRADeviceTaints feature gate.
|
|
393
489
|
"""
|
|
490
|
+
if all_nodes is not None:
|
|
491
|
+
pulumi.set(__self__, "all_nodes", all_nodes)
|
|
394
492
|
if attributes is not None:
|
|
395
493
|
pulumi.set(__self__, "attributes", attributes)
|
|
396
494
|
if capacity is not None:
|
|
397
495
|
pulumi.set(__self__, "capacity", capacity)
|
|
496
|
+
if consumes_counters is not None:
|
|
497
|
+
pulumi.set(__self__, "consumes_counters", consumes_counters)
|
|
498
|
+
if node_name is not None:
|
|
499
|
+
pulumi.set(__self__, "node_name", node_name)
|
|
500
|
+
if node_selector is not None:
|
|
501
|
+
pulumi.set(__self__, "node_selector", node_selector)
|
|
502
|
+
if taints is not None:
|
|
503
|
+
pulumi.set(__self__, "taints", taints)
|
|
504
|
+
|
|
505
|
+
@property
|
|
506
|
+
@pulumi.getter(name="allNodes")
|
|
507
|
+
def all_nodes(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
508
|
+
"""
|
|
509
|
+
AllNodes indicates that all nodes have access to the device.
|
|
510
|
+
|
|
511
|
+
Must only be set if Spec.PerDeviceNodeSelection is set to true. At most one of NodeName, NodeSelector and AllNodes can be set.
|
|
512
|
+
"""
|
|
513
|
+
return pulumi.get(self, "all_nodes")
|
|
514
|
+
|
|
515
|
+
@all_nodes.setter
|
|
516
|
+
def all_nodes(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
517
|
+
pulumi.set(self, "all_nodes", value)
|
|
398
518
|
|
|
399
519
|
@property
|
|
400
520
|
@pulumi.getter
|
|
@@ -424,12 +544,78 @@ class BasicDevicePatchArgs:
|
|
|
424
544
|
def capacity(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]):
|
|
425
545
|
pulumi.set(self, "capacity", value)
|
|
426
546
|
|
|
547
|
+
@property
|
|
548
|
+
@pulumi.getter(name="consumesCounters")
|
|
549
|
+
def consumes_counters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DeviceCounterConsumptionPatchArgs']]]]:
|
|
550
|
+
"""
|
|
551
|
+
ConsumesCounters defines a list of references to sharedCounters and the set of counters that the device will consume from those counter sets.
|
|
552
|
+
|
|
553
|
+
There can only be a single entry per counterSet.
|
|
554
|
+
|
|
555
|
+
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).
|
|
556
|
+
"""
|
|
557
|
+
return pulumi.get(self, "consumes_counters")
|
|
558
|
+
|
|
559
|
+
@consumes_counters.setter
|
|
560
|
+
def consumes_counters(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DeviceCounterConsumptionPatchArgs']]]]):
|
|
561
|
+
pulumi.set(self, "consumes_counters", value)
|
|
562
|
+
|
|
563
|
+
@property
|
|
564
|
+
@pulumi.getter(name="nodeName")
|
|
565
|
+
def node_name(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
566
|
+
"""
|
|
567
|
+
NodeName identifies the node where the device is available.
|
|
568
|
+
|
|
569
|
+
Must only be set if Spec.PerDeviceNodeSelection is set to true. At most one of NodeName, NodeSelector and AllNodes can be set.
|
|
570
|
+
"""
|
|
571
|
+
return pulumi.get(self, "node_name")
|
|
572
|
+
|
|
573
|
+
@node_name.setter
|
|
574
|
+
def node_name(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
575
|
+
pulumi.set(self, "node_name", value)
|
|
576
|
+
|
|
577
|
+
@property
|
|
578
|
+
@pulumi.getter(name="nodeSelector")
|
|
579
|
+
def node_selector(self) -> Optional[pulumi.Input['_core.v1.NodeSelectorPatchArgs']]:
|
|
580
|
+
"""
|
|
581
|
+
NodeSelector defines the nodes where the device is available.
|
|
582
|
+
|
|
583
|
+
Must only be set if Spec.PerDeviceNodeSelection is set to true. At most one of NodeName, NodeSelector and AllNodes can be set.
|
|
584
|
+
"""
|
|
585
|
+
return pulumi.get(self, "node_selector")
|
|
586
|
+
|
|
587
|
+
@node_selector.setter
|
|
588
|
+
def node_selector(self, value: Optional[pulumi.Input['_core.v1.NodeSelectorPatchArgs']]):
|
|
589
|
+
pulumi.set(self, "node_selector", value)
|
|
590
|
+
|
|
591
|
+
@property
|
|
592
|
+
@pulumi.getter
|
|
593
|
+
def taints(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DeviceTaintPatchArgs']]]]:
|
|
594
|
+
"""
|
|
595
|
+
If specified, these are the driver-defined taints.
|
|
596
|
+
|
|
597
|
+
The maximum number of taints is 4.
|
|
598
|
+
|
|
599
|
+
This is an alpha field and requires enabling the DRADeviceTaints feature gate.
|
|
600
|
+
"""
|
|
601
|
+
return pulumi.get(self, "taints")
|
|
602
|
+
|
|
603
|
+
@taints.setter
|
|
604
|
+
def taints(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DeviceTaintPatchArgs']]]]):
|
|
605
|
+
pulumi.set(self, "taints", value)
|
|
606
|
+
|
|
427
607
|
|
|
428
608
|
if not MYPY:
|
|
429
609
|
class BasicDeviceArgsDict(TypedDict):
|
|
430
610
|
"""
|
|
431
611
|
BasicDevice defines one device instance.
|
|
432
612
|
"""
|
|
613
|
+
all_nodes: NotRequired[pulumi.Input[builtins.bool]]
|
|
614
|
+
"""
|
|
615
|
+
AllNodes indicates that all nodes have access to the device.
|
|
616
|
+
|
|
617
|
+
Must only be set if Spec.PerDeviceNodeSelection is set to true. At most one of NodeName, NodeSelector and AllNodes can be set.
|
|
618
|
+
"""
|
|
433
619
|
attributes: NotRequired[pulumi.Input[Mapping[str, pulumi.Input['DeviceAttributeArgsDict']]]]
|
|
434
620
|
"""
|
|
435
621
|
Attributes defines the set of attributes for this device. The name of each attribute must be unique in that set.
|
|
@@ -442,27 +628,103 @@ if not MYPY:
|
|
|
442
628
|
|
|
443
629
|
The maximum number of attributes and capacities combined is 32.
|
|
444
630
|
"""
|
|
631
|
+
consumes_counters: NotRequired[pulumi.Input[Sequence[pulumi.Input['DeviceCounterConsumptionArgsDict']]]]
|
|
632
|
+
"""
|
|
633
|
+
ConsumesCounters defines a list of references to sharedCounters and the set of counters that the device will consume from those counter sets.
|
|
634
|
+
|
|
635
|
+
There can only be a single entry per counterSet.
|
|
636
|
+
|
|
637
|
+
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).
|
|
638
|
+
"""
|
|
639
|
+
node_name: NotRequired[pulumi.Input[builtins.str]]
|
|
640
|
+
"""
|
|
641
|
+
NodeName identifies the node where the device is available.
|
|
642
|
+
|
|
643
|
+
Must only be set if Spec.PerDeviceNodeSelection is set to true. At most one of NodeName, NodeSelector and AllNodes can be set.
|
|
644
|
+
"""
|
|
645
|
+
node_selector: NotRequired[pulumi.Input['_core.v1.NodeSelectorArgsDict']]
|
|
646
|
+
"""
|
|
647
|
+
NodeSelector defines the nodes where the device is available.
|
|
648
|
+
|
|
649
|
+
Must only be set if Spec.PerDeviceNodeSelection is set to true. At most one of NodeName, NodeSelector and AllNodes can be set.
|
|
650
|
+
"""
|
|
651
|
+
taints: NotRequired[pulumi.Input[Sequence[pulumi.Input['DeviceTaintArgsDict']]]]
|
|
652
|
+
"""
|
|
653
|
+
If specified, these are the driver-defined taints.
|
|
654
|
+
|
|
655
|
+
The maximum number of taints is 4.
|
|
656
|
+
|
|
657
|
+
This is an alpha field and requires enabling the DRADeviceTaints feature gate.
|
|
658
|
+
"""
|
|
445
659
|
elif False:
|
|
446
660
|
BasicDeviceArgsDict: TypeAlias = Mapping[str, Any]
|
|
447
661
|
|
|
448
662
|
@pulumi.input_type
|
|
449
663
|
class BasicDeviceArgs:
|
|
450
664
|
def __init__(__self__, *,
|
|
665
|
+
all_nodes: Optional[pulumi.Input[builtins.bool]] = None,
|
|
451
666
|
attributes: Optional[pulumi.Input[Mapping[str, pulumi.Input['DeviceAttributeArgs']]]] = None,
|
|
452
|
-
capacity: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None
|
|
667
|
+
capacity: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None,
|
|
668
|
+
consumes_counters: Optional[pulumi.Input[Sequence[pulumi.Input['DeviceCounterConsumptionArgs']]]] = None,
|
|
669
|
+
node_name: Optional[pulumi.Input[builtins.str]] = None,
|
|
670
|
+
node_selector: Optional[pulumi.Input['_core.v1.NodeSelectorArgs']] = None,
|
|
671
|
+
taints: Optional[pulumi.Input[Sequence[pulumi.Input['DeviceTaintArgs']]]] = None):
|
|
453
672
|
"""
|
|
454
673
|
BasicDevice defines one device instance.
|
|
674
|
+
:param pulumi.Input[builtins.bool] all_nodes: AllNodes indicates that all nodes have access to the device.
|
|
675
|
+
|
|
676
|
+
Must only be set if Spec.PerDeviceNodeSelection is set to true. At most one of NodeName, NodeSelector and AllNodes can be set.
|
|
455
677
|
: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.
|
|
456
678
|
|
|
457
679
|
The maximum number of attributes and capacities combined is 32.
|
|
458
680
|
:param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] capacity: Capacity defines the set of capacities for this device. The name of each capacity must be unique in that set.
|
|
459
681
|
|
|
460
682
|
The maximum number of attributes and capacities combined is 32.
|
|
683
|
+
: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.
|
|
684
|
+
|
|
685
|
+
There can only be a single entry per counterSet.
|
|
686
|
+
|
|
687
|
+
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).
|
|
688
|
+
:param pulumi.Input[builtins.str] node_name: NodeName identifies the node where the device is available.
|
|
689
|
+
|
|
690
|
+
Must only be set if Spec.PerDeviceNodeSelection is set to true. At most one of NodeName, NodeSelector and AllNodes can be set.
|
|
691
|
+
:param pulumi.Input['_core.v1.NodeSelectorArgs'] node_selector: NodeSelector defines the nodes where the device is available.
|
|
692
|
+
|
|
693
|
+
Must only be set if Spec.PerDeviceNodeSelection is set to true. At most one of NodeName, NodeSelector and AllNodes can be set.
|
|
694
|
+
:param pulumi.Input[Sequence[pulumi.Input['DeviceTaintArgs']]] taints: If specified, these are the driver-defined taints.
|
|
695
|
+
|
|
696
|
+
The maximum number of taints is 4.
|
|
697
|
+
|
|
698
|
+
This is an alpha field and requires enabling the DRADeviceTaints feature gate.
|
|
461
699
|
"""
|
|
700
|
+
if all_nodes is not None:
|
|
701
|
+
pulumi.set(__self__, "all_nodes", all_nodes)
|
|
462
702
|
if attributes is not None:
|
|
463
703
|
pulumi.set(__self__, "attributes", attributes)
|
|
464
704
|
if capacity is not None:
|
|
465
705
|
pulumi.set(__self__, "capacity", capacity)
|
|
706
|
+
if consumes_counters is not None:
|
|
707
|
+
pulumi.set(__self__, "consumes_counters", consumes_counters)
|
|
708
|
+
if node_name is not None:
|
|
709
|
+
pulumi.set(__self__, "node_name", node_name)
|
|
710
|
+
if node_selector is not None:
|
|
711
|
+
pulumi.set(__self__, "node_selector", node_selector)
|
|
712
|
+
if taints is not None:
|
|
713
|
+
pulumi.set(__self__, "taints", taints)
|
|
714
|
+
|
|
715
|
+
@property
|
|
716
|
+
@pulumi.getter(name="allNodes")
|
|
717
|
+
def all_nodes(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
718
|
+
"""
|
|
719
|
+
AllNodes indicates that all nodes have access to the device.
|
|
720
|
+
|
|
721
|
+
Must only be set if Spec.PerDeviceNodeSelection is set to true. At most one of NodeName, NodeSelector and AllNodes can be set.
|
|
722
|
+
"""
|
|
723
|
+
return pulumi.get(self, "all_nodes")
|
|
724
|
+
|
|
725
|
+
@all_nodes.setter
|
|
726
|
+
def all_nodes(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
727
|
+
pulumi.set(self, "all_nodes", value)
|
|
466
728
|
|
|
467
729
|
@property
|
|
468
730
|
@pulumi.getter
|
|
@@ -492,6 +754,66 @@ class BasicDeviceArgs:
|
|
|
492
754
|
def capacity(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]):
|
|
493
755
|
pulumi.set(self, "capacity", value)
|
|
494
756
|
|
|
757
|
+
@property
|
|
758
|
+
@pulumi.getter(name="consumesCounters")
|
|
759
|
+
def consumes_counters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DeviceCounterConsumptionArgs']]]]:
|
|
760
|
+
"""
|
|
761
|
+
ConsumesCounters defines a list of references to sharedCounters and the set of counters that the device will consume from those counter sets.
|
|
762
|
+
|
|
763
|
+
There can only be a single entry per counterSet.
|
|
764
|
+
|
|
765
|
+
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).
|
|
766
|
+
"""
|
|
767
|
+
return pulumi.get(self, "consumes_counters")
|
|
768
|
+
|
|
769
|
+
@consumes_counters.setter
|
|
770
|
+
def consumes_counters(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DeviceCounterConsumptionArgs']]]]):
|
|
771
|
+
pulumi.set(self, "consumes_counters", value)
|
|
772
|
+
|
|
773
|
+
@property
|
|
774
|
+
@pulumi.getter(name="nodeName")
|
|
775
|
+
def node_name(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
776
|
+
"""
|
|
777
|
+
NodeName identifies the node where the device is available.
|
|
778
|
+
|
|
779
|
+
Must only be set if Spec.PerDeviceNodeSelection is set to true. At most one of NodeName, NodeSelector and AllNodes can be set.
|
|
780
|
+
"""
|
|
781
|
+
return pulumi.get(self, "node_name")
|
|
782
|
+
|
|
783
|
+
@node_name.setter
|
|
784
|
+
def node_name(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
785
|
+
pulumi.set(self, "node_name", value)
|
|
786
|
+
|
|
787
|
+
@property
|
|
788
|
+
@pulumi.getter(name="nodeSelector")
|
|
789
|
+
def node_selector(self) -> Optional[pulumi.Input['_core.v1.NodeSelectorArgs']]:
|
|
790
|
+
"""
|
|
791
|
+
NodeSelector defines the nodes where the device is available.
|
|
792
|
+
|
|
793
|
+
Must only be set if Spec.PerDeviceNodeSelection is set to true. At most one of NodeName, NodeSelector and AllNodes can be set.
|
|
794
|
+
"""
|
|
795
|
+
return pulumi.get(self, "node_selector")
|
|
796
|
+
|
|
797
|
+
@node_selector.setter
|
|
798
|
+
def node_selector(self, value: Optional[pulumi.Input['_core.v1.NodeSelectorArgs']]):
|
|
799
|
+
pulumi.set(self, "node_selector", value)
|
|
800
|
+
|
|
801
|
+
@property
|
|
802
|
+
@pulumi.getter
|
|
803
|
+
def taints(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DeviceTaintArgs']]]]:
|
|
804
|
+
"""
|
|
805
|
+
If specified, these are the driver-defined taints.
|
|
806
|
+
|
|
807
|
+
The maximum number of taints is 4.
|
|
808
|
+
|
|
809
|
+
This is an alpha field and requires enabling the DRADeviceTaints feature gate.
|
|
810
|
+
"""
|
|
811
|
+
return pulumi.get(self, "taints")
|
|
812
|
+
|
|
813
|
+
@taints.setter
|
|
814
|
+
def taints(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DeviceTaintArgs']]]]):
|
|
815
|
+
pulumi.set(self, "taints", value)
|
|
816
|
+
|
|
495
817
|
|
|
496
818
|
if not MYPY:
|
|
497
819
|
class CELDeviceSelectorPatchArgsDict(TypedDict):
|
|
@@ -733,109 +1055,292 @@ class CELDeviceSelectorArgs:
|
|
|
733
1055
|
|
|
734
1056
|
|
|
735
1057
|
if not MYPY:
|
|
736
|
-
class
|
|
737
|
-
"""
|
|
738
|
-
DeviceAllocationConfiguration gets embedded in an AllocationResult.
|
|
739
|
-
"""
|
|
740
|
-
source: pulumi.Input[builtins.str]
|
|
1058
|
+
class CounterSetPatchArgsDict(TypedDict):
|
|
741
1059
|
"""
|
|
742
|
-
|
|
1060
|
+
CounterSet defines a named set of counters that are available to be used by devices defined in the ResourceSlice.
|
|
1061
|
+
|
|
1062
|
+
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.
|
|
743
1063
|
"""
|
|
744
|
-
|
|
1064
|
+
counters: NotRequired[pulumi.Input[Mapping[str, pulumi.Input['CounterArgsDict']]]]
|
|
745
1065
|
"""
|
|
746
|
-
|
|
1066
|
+
Counters defines the counters that will be consumed by the device. The name of each counter must be unique in that set and must be a DNS label.
|
|
1067
|
+
|
|
1068
|
+
To ensure this uniqueness, capacities defined by the vendor must be listed without the driver name as domain prefix in their name. All others must be listed with their domain prefix.
|
|
1069
|
+
|
|
1070
|
+
The maximum number of counters is 32.
|
|
747
1071
|
"""
|
|
748
|
-
|
|
1072
|
+
name: NotRequired[pulumi.Input[builtins.str]]
|
|
749
1073
|
"""
|
|
750
|
-
|
|
1074
|
+
CounterSet is the name of the set from which the counters defined will be consumed.
|
|
751
1075
|
"""
|
|
752
1076
|
elif False:
|
|
753
|
-
|
|
1077
|
+
CounterSetPatchArgsDict: TypeAlias = Mapping[str, Any]
|
|
754
1078
|
|
|
755
1079
|
@pulumi.input_type
|
|
756
|
-
class
|
|
1080
|
+
class CounterSetPatchArgs:
|
|
757
1081
|
def __init__(__self__, *,
|
|
758
|
-
|
|
759
|
-
|
|
760
|
-
requests: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None):
|
|
1082
|
+
counters: Optional[pulumi.Input[Mapping[str, pulumi.Input['CounterArgs']]]] = None,
|
|
1083
|
+
name: Optional[pulumi.Input[builtins.str]] = None):
|
|
761
1084
|
"""
|
|
762
|
-
|
|
763
|
-
|
|
764
|
-
|
|
765
|
-
:param pulumi.Input[
|
|
1085
|
+
CounterSet defines a named set of counters that are available to be used by devices defined in the ResourceSlice.
|
|
1086
|
+
|
|
1087
|
+
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.
|
|
1088
|
+
:param pulumi.Input[Mapping[str, pulumi.Input['CounterArgs']]] counters: Counters defines the counters that will be consumed by the device. The name of each counter must be unique in that set and must be a DNS label.
|
|
1089
|
+
|
|
1090
|
+
To ensure this uniqueness, capacities defined by the vendor must be listed without the driver name as domain prefix in their name. All others must be listed with their domain prefix.
|
|
1091
|
+
|
|
1092
|
+
The maximum number of counters is 32.
|
|
1093
|
+
:param pulumi.Input[builtins.str] name: CounterSet is the name of the set from which the counters defined will be consumed.
|
|
766
1094
|
"""
|
|
767
|
-
|
|
768
|
-
|
|
769
|
-
|
|
770
|
-
|
|
771
|
-
pulumi.set(__self__, "requests", requests)
|
|
1095
|
+
if counters is not None:
|
|
1096
|
+
pulumi.set(__self__, "counters", counters)
|
|
1097
|
+
if name is not None:
|
|
1098
|
+
pulumi.set(__self__, "name", name)
|
|
772
1099
|
|
|
773
1100
|
@property
|
|
774
1101
|
@pulumi.getter
|
|
775
|
-
def
|
|
776
|
-
"""
|
|
777
|
-
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.
|
|
1102
|
+
def counters(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input['CounterArgs']]]]:
|
|
778
1103
|
"""
|
|
779
|
-
|
|
1104
|
+
Counters defines the counters that will be consumed by the device. The name of each counter must be unique in that set and must be a DNS label.
|
|
780
1105
|
|
|
781
|
-
|
|
782
|
-
def source(self, value: pulumi.Input[builtins.str]):
|
|
783
|
-
pulumi.set(self, "source", value)
|
|
1106
|
+
To ensure this uniqueness, capacities defined by the vendor must be listed without the driver name as domain prefix in their name. All others must be listed with their domain prefix.
|
|
784
1107
|
|
|
785
|
-
|
|
786
|
-
@pulumi.getter
|
|
787
|
-
def opaque(self) -> Optional[pulumi.Input['OpaqueDeviceConfigurationArgs']]:
|
|
1108
|
+
The maximum number of counters is 32.
|
|
788
1109
|
"""
|
|
789
|
-
|
|
790
|
-
"""
|
|
791
|
-
return pulumi.get(self, "opaque")
|
|
1110
|
+
return pulumi.get(self, "counters")
|
|
792
1111
|
|
|
793
|
-
@
|
|
794
|
-
def
|
|
795
|
-
pulumi.set(self, "
|
|
1112
|
+
@counters.setter
|
|
1113
|
+
def counters(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input['CounterArgs']]]]):
|
|
1114
|
+
pulumi.set(self, "counters", value)
|
|
796
1115
|
|
|
797
1116
|
@property
|
|
798
1117
|
@pulumi.getter
|
|
799
|
-
def
|
|
1118
|
+
def name(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
800
1119
|
"""
|
|
801
|
-
|
|
1120
|
+
CounterSet is the name of the set from which the counters defined will be consumed.
|
|
802
1121
|
"""
|
|
803
|
-
return pulumi.get(self, "
|
|
1122
|
+
return pulumi.get(self, "name")
|
|
804
1123
|
|
|
805
|
-
@
|
|
806
|
-
def
|
|
807
|
-
pulumi.set(self, "
|
|
1124
|
+
@name.setter
|
|
1125
|
+
def name(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
1126
|
+
pulumi.set(self, "name", value)
|
|
808
1127
|
|
|
809
1128
|
|
|
810
1129
|
if not MYPY:
|
|
811
|
-
class
|
|
1130
|
+
class CounterSetArgsDict(TypedDict):
|
|
812
1131
|
"""
|
|
813
|
-
|
|
1132
|
+
CounterSet defines a named set of counters that are available to be used by devices defined in the ResourceSlice.
|
|
1133
|
+
|
|
1134
|
+
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.
|
|
814
1135
|
"""
|
|
815
|
-
|
|
1136
|
+
counters: pulumi.Input[Mapping[str, pulumi.Input['CounterArgsDict']]]
|
|
816
1137
|
"""
|
|
817
|
-
|
|
1138
|
+
Counters defines the counters that will be consumed by the device. The name of each counter must be unique in that set and must be a DNS label.
|
|
818
1139
|
|
|
819
|
-
|
|
1140
|
+
To ensure this uniqueness, capacities defined by the vendor must be listed without the driver name as domain prefix in their name. All others must be listed with their domain prefix.
|
|
1141
|
+
|
|
1142
|
+
The maximum number of counters is 32.
|
|
820
1143
|
"""
|
|
821
|
-
|
|
1144
|
+
name: pulumi.Input[builtins.str]
|
|
822
1145
|
"""
|
|
823
|
-
|
|
1146
|
+
CounterSet is the name of the set from which the counters defined will be consumed.
|
|
824
1147
|
"""
|
|
825
1148
|
elif False:
|
|
826
|
-
|
|
1149
|
+
CounterSetArgsDict: TypeAlias = Mapping[str, Any]
|
|
827
1150
|
|
|
828
1151
|
@pulumi.input_type
|
|
829
|
-
class
|
|
1152
|
+
class CounterSetArgs:
|
|
830
1153
|
def __init__(__self__, *,
|
|
831
|
-
|
|
832
|
-
|
|
1154
|
+
counters: pulumi.Input[Mapping[str, pulumi.Input['CounterArgs']]],
|
|
1155
|
+
name: pulumi.Input[builtins.str]):
|
|
833
1156
|
"""
|
|
834
|
-
|
|
835
|
-
|
|
1157
|
+
CounterSet defines a named set of counters that are available to be used by devices defined in the ResourceSlice.
|
|
1158
|
+
|
|
1159
|
+
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.
|
|
1160
|
+
:param pulumi.Input[Mapping[str, pulumi.Input['CounterArgs']]] counters: Counters defines the counters that will be consumed by the device. The name of each counter must be unique in that set and must be a DNS label.
|
|
836
1161
|
|
|
837
|
-
|
|
838
|
-
|
|
1162
|
+
To ensure this uniqueness, capacities defined by the vendor must be listed without the driver name as domain prefix in their name. All others must be listed with their domain prefix.
|
|
1163
|
+
|
|
1164
|
+
The maximum number of counters is 32.
|
|
1165
|
+
:param pulumi.Input[builtins.str] name: CounterSet is the name of the set from which the counters defined will be consumed.
|
|
1166
|
+
"""
|
|
1167
|
+
pulumi.set(__self__, "counters", counters)
|
|
1168
|
+
pulumi.set(__self__, "name", name)
|
|
1169
|
+
|
|
1170
|
+
@property
|
|
1171
|
+
@pulumi.getter
|
|
1172
|
+
def counters(self) -> pulumi.Input[Mapping[str, pulumi.Input['CounterArgs']]]:
|
|
1173
|
+
"""
|
|
1174
|
+
Counters defines the counters that will be consumed by the device. The name of each counter must be unique in that set and must be a DNS label.
|
|
1175
|
+
|
|
1176
|
+
To ensure this uniqueness, capacities defined by the vendor must be listed without the driver name as domain prefix in their name. All others must be listed with their domain prefix.
|
|
1177
|
+
|
|
1178
|
+
The maximum number of counters is 32.
|
|
1179
|
+
"""
|
|
1180
|
+
return pulumi.get(self, "counters")
|
|
1181
|
+
|
|
1182
|
+
@counters.setter
|
|
1183
|
+
def counters(self, value: pulumi.Input[Mapping[str, pulumi.Input['CounterArgs']]]):
|
|
1184
|
+
pulumi.set(self, "counters", value)
|
|
1185
|
+
|
|
1186
|
+
@property
|
|
1187
|
+
@pulumi.getter
|
|
1188
|
+
def name(self) -> pulumi.Input[builtins.str]:
|
|
1189
|
+
"""
|
|
1190
|
+
CounterSet is the name of the set from which the counters defined will be consumed.
|
|
1191
|
+
"""
|
|
1192
|
+
return pulumi.get(self, "name")
|
|
1193
|
+
|
|
1194
|
+
@name.setter
|
|
1195
|
+
def name(self, value: pulumi.Input[builtins.str]):
|
|
1196
|
+
pulumi.set(self, "name", value)
|
|
1197
|
+
|
|
1198
|
+
|
|
1199
|
+
if not MYPY:
|
|
1200
|
+
class CounterArgsDict(TypedDict):
|
|
1201
|
+
"""
|
|
1202
|
+
Counter describes a quantity associated with a device.
|
|
1203
|
+
"""
|
|
1204
|
+
value: pulumi.Input[builtins.str]
|
|
1205
|
+
"""
|
|
1206
|
+
Value defines how much of a certain device counter is available.
|
|
1207
|
+
"""
|
|
1208
|
+
elif False:
|
|
1209
|
+
CounterArgsDict: TypeAlias = Mapping[str, Any]
|
|
1210
|
+
|
|
1211
|
+
@pulumi.input_type
|
|
1212
|
+
class CounterArgs:
|
|
1213
|
+
def __init__(__self__, *,
|
|
1214
|
+
value: pulumi.Input[builtins.str]):
|
|
1215
|
+
"""
|
|
1216
|
+
Counter describes a quantity associated with a device.
|
|
1217
|
+
:param pulumi.Input[builtins.str] value: Value defines how much of a certain device counter is available.
|
|
1218
|
+
"""
|
|
1219
|
+
pulumi.set(__self__, "value", value)
|
|
1220
|
+
|
|
1221
|
+
@property
|
|
1222
|
+
@pulumi.getter
|
|
1223
|
+
def value(self) -> pulumi.Input[builtins.str]:
|
|
1224
|
+
"""
|
|
1225
|
+
Value defines how much of a certain device counter is available.
|
|
1226
|
+
"""
|
|
1227
|
+
return pulumi.get(self, "value")
|
|
1228
|
+
|
|
1229
|
+
@value.setter
|
|
1230
|
+
def value(self, value: pulumi.Input[builtins.str]):
|
|
1231
|
+
pulumi.set(self, "value", value)
|
|
1232
|
+
|
|
1233
|
+
|
|
1234
|
+
if not MYPY:
|
|
1235
|
+
class DeviceAllocationConfigurationArgsDict(TypedDict):
|
|
1236
|
+
"""
|
|
1237
|
+
DeviceAllocationConfiguration gets embedded in an AllocationResult.
|
|
1238
|
+
"""
|
|
1239
|
+
source: pulumi.Input[builtins.str]
|
|
1240
|
+
"""
|
|
1241
|
+
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.
|
|
1242
|
+
"""
|
|
1243
|
+
opaque: NotRequired[pulumi.Input['OpaqueDeviceConfigurationArgsDict']]
|
|
1244
|
+
"""
|
|
1245
|
+
Opaque provides driver-specific configuration parameters.
|
|
1246
|
+
"""
|
|
1247
|
+
requests: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
|
|
1248
|
+
"""
|
|
1249
|
+
Requests lists the names of requests where the configuration applies. If empty, its applies to all requests.
|
|
1250
|
+
|
|
1251
|
+
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.
|
|
1252
|
+
"""
|
|
1253
|
+
elif False:
|
|
1254
|
+
DeviceAllocationConfigurationArgsDict: TypeAlias = Mapping[str, Any]
|
|
1255
|
+
|
|
1256
|
+
@pulumi.input_type
|
|
1257
|
+
class DeviceAllocationConfigurationArgs:
|
|
1258
|
+
def __init__(__self__, *,
|
|
1259
|
+
source: pulumi.Input[builtins.str],
|
|
1260
|
+
opaque: Optional[pulumi.Input['OpaqueDeviceConfigurationArgs']] = None,
|
|
1261
|
+
requests: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None):
|
|
1262
|
+
"""
|
|
1263
|
+
DeviceAllocationConfiguration gets embedded in an AllocationResult.
|
|
1264
|
+
: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.
|
|
1265
|
+
:param pulumi.Input['OpaqueDeviceConfigurationArgs'] opaque: Opaque provides driver-specific configuration parameters.
|
|
1266
|
+
: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.
|
|
1267
|
+
|
|
1268
|
+
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.
|
|
1269
|
+
"""
|
|
1270
|
+
pulumi.set(__self__, "source", source)
|
|
1271
|
+
if opaque is not None:
|
|
1272
|
+
pulumi.set(__self__, "opaque", opaque)
|
|
1273
|
+
if requests is not None:
|
|
1274
|
+
pulumi.set(__self__, "requests", requests)
|
|
1275
|
+
|
|
1276
|
+
@property
|
|
1277
|
+
@pulumi.getter
|
|
1278
|
+
def source(self) -> pulumi.Input[builtins.str]:
|
|
1279
|
+
"""
|
|
1280
|
+
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.
|
|
1281
|
+
"""
|
|
1282
|
+
return pulumi.get(self, "source")
|
|
1283
|
+
|
|
1284
|
+
@source.setter
|
|
1285
|
+
def source(self, value: pulumi.Input[builtins.str]):
|
|
1286
|
+
pulumi.set(self, "source", value)
|
|
1287
|
+
|
|
1288
|
+
@property
|
|
1289
|
+
@pulumi.getter
|
|
1290
|
+
def opaque(self) -> Optional[pulumi.Input['OpaqueDeviceConfigurationArgs']]:
|
|
1291
|
+
"""
|
|
1292
|
+
Opaque provides driver-specific configuration parameters.
|
|
1293
|
+
"""
|
|
1294
|
+
return pulumi.get(self, "opaque")
|
|
1295
|
+
|
|
1296
|
+
@opaque.setter
|
|
1297
|
+
def opaque(self, value: Optional[pulumi.Input['OpaqueDeviceConfigurationArgs']]):
|
|
1298
|
+
pulumi.set(self, "opaque", value)
|
|
1299
|
+
|
|
1300
|
+
@property
|
|
1301
|
+
@pulumi.getter
|
|
1302
|
+
def requests(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
1303
|
+
"""
|
|
1304
|
+
Requests lists the names of requests where the configuration applies. If empty, its applies to all requests.
|
|
1305
|
+
|
|
1306
|
+
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.
|
|
1307
|
+
"""
|
|
1308
|
+
return pulumi.get(self, "requests")
|
|
1309
|
+
|
|
1310
|
+
@requests.setter
|
|
1311
|
+
def requests(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
|
|
1312
|
+
pulumi.set(self, "requests", value)
|
|
1313
|
+
|
|
1314
|
+
|
|
1315
|
+
if not MYPY:
|
|
1316
|
+
class DeviceAllocationResultArgsDict(TypedDict):
|
|
1317
|
+
"""
|
|
1318
|
+
DeviceAllocationResult is the result of allocating devices.
|
|
1319
|
+
"""
|
|
1320
|
+
config: NotRequired[pulumi.Input[Sequence[pulumi.Input['DeviceAllocationConfigurationArgsDict']]]]
|
|
1321
|
+
"""
|
|
1322
|
+
This field is a combination of all the claim and class configuration parameters. Drivers can distinguish between those based on a flag.
|
|
1323
|
+
|
|
1324
|
+
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.
|
|
1325
|
+
"""
|
|
1326
|
+
results: NotRequired[pulumi.Input[Sequence[pulumi.Input['DeviceRequestAllocationResultArgsDict']]]]
|
|
1327
|
+
"""
|
|
1328
|
+
Results lists all allocated devices.
|
|
1329
|
+
"""
|
|
1330
|
+
elif False:
|
|
1331
|
+
DeviceAllocationResultArgsDict: TypeAlias = Mapping[str, Any]
|
|
1332
|
+
|
|
1333
|
+
@pulumi.input_type
|
|
1334
|
+
class DeviceAllocationResultArgs:
|
|
1335
|
+
def __init__(__self__, *,
|
|
1336
|
+
config: Optional[pulumi.Input[Sequence[pulumi.Input['DeviceAllocationConfigurationArgs']]]] = None,
|
|
1337
|
+
results: Optional[pulumi.Input[Sequence[pulumi.Input['DeviceRequestAllocationResultArgs']]]] = None):
|
|
1338
|
+
"""
|
|
1339
|
+
DeviceAllocationResult is the result of allocating devices.
|
|
1340
|
+
:param pulumi.Input[Sequence[pulumi.Input['DeviceAllocationConfigurationArgs']]] config: This field is a combination of all the claim and class configuration parameters. Drivers can distinguish between those based on a flag.
|
|
1341
|
+
|
|
1342
|
+
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.
|
|
1343
|
+
:param pulumi.Input[Sequence[pulumi.Input['DeviceRequestAllocationResultArgs']]] results: Results lists all allocated devices.
|
|
839
1344
|
"""
|
|
840
1345
|
if config is not None:
|
|
841
1346
|
pulumi.set(__self__, "config", config)
|
|
@@ -977,6 +1482,8 @@ if not MYPY:
|
|
|
977
1482
|
requests: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
|
|
978
1483
|
"""
|
|
979
1484
|
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.
|
|
980
1487
|
"""
|
|
981
1488
|
elif False:
|
|
982
1489
|
DeviceClaimConfigurationPatchArgsDict: TypeAlias = Mapping[str, Any]
|
|
@@ -990,6 +1497,8 @@ class DeviceClaimConfigurationPatchArgs:
|
|
|
990
1497
|
DeviceClaimConfiguration is used for configuration parameters in DeviceClaim.
|
|
991
1498
|
:param pulumi.Input['OpaqueDeviceConfigurationPatchArgs'] opaque: Opaque provides driver-specific configuration parameters.
|
|
992
1499
|
: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.
|
|
1500
|
+
|
|
1501
|
+
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.
|
|
993
1502
|
"""
|
|
994
1503
|
if opaque is not None:
|
|
995
1504
|
pulumi.set(__self__, "opaque", opaque)
|
|
@@ -1013,6 +1522,8 @@ class DeviceClaimConfigurationPatchArgs:
|
|
|
1013
1522
|
def requests(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
1014
1523
|
"""
|
|
1015
1524
|
Requests lists the names of requests where the configuration applies. If empty, it applies to all requests.
|
|
1525
|
+
|
|
1526
|
+
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.
|
|
1016
1527
|
"""
|
|
1017
1528
|
return pulumi.get(self, "requests")
|
|
1018
1529
|
|
|
@@ -1033,6 +1544,8 @@ if not MYPY:
|
|
|
1033
1544
|
requests: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
|
|
1034
1545
|
"""
|
|
1035
1546
|
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.
|
|
1036
1549
|
"""
|
|
1037
1550
|
elif False:
|
|
1038
1551
|
DeviceClaimConfigurationArgsDict: TypeAlias = Mapping[str, Any]
|
|
@@ -1046,6 +1559,8 @@ class DeviceClaimConfigurationArgs:
|
|
|
1046
1559
|
DeviceClaimConfiguration is used for configuration parameters in DeviceClaim.
|
|
1047
1560
|
:param pulumi.Input['OpaqueDeviceConfigurationArgs'] opaque: Opaque provides driver-specific configuration parameters.
|
|
1048
1561
|
: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.
|
|
1562
|
+
|
|
1563
|
+
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.
|
|
1049
1564
|
"""
|
|
1050
1565
|
if opaque is not None:
|
|
1051
1566
|
pulumi.set(__self__, "opaque", opaque)
|
|
@@ -1069,6 +1584,8 @@ class DeviceClaimConfigurationArgs:
|
|
|
1069
1584
|
def requests(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
1070
1585
|
"""
|
|
1071
1586
|
Requests lists the names of requests where the configuration applies. If empty, it applies to all requests.
|
|
1587
|
+
|
|
1588
|
+
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.
|
|
1072
1589
|
"""
|
|
1073
1590
|
return pulumi.get(self, "requests")
|
|
1074
1591
|
|
|
@@ -1616,6 +2133,8 @@ if not MYPY:
|
|
|
1616
2133
|
requests: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
|
|
1617
2134
|
"""
|
|
1618
2135
|
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.
|
|
2136
|
+
|
|
2137
|
+
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.
|
|
1619
2138
|
"""
|
|
1620
2139
|
elif False:
|
|
1621
2140
|
DeviceConstraintPatchArgsDict: TypeAlias = Mapping[str, Any]
|
|
@@ -1633,6 +2152,8 @@ class DeviceConstraintPatchArgs:
|
|
|
1633
2152
|
|
|
1634
2153
|
Must include the domain qualifier.
|
|
1635
2154
|
: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.
|
|
2155
|
+
|
|
2156
|
+
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.
|
|
1636
2157
|
"""
|
|
1637
2158
|
if match_attribute is not None:
|
|
1638
2159
|
pulumi.set(__self__, "match_attribute", match_attribute)
|
|
@@ -1660,6 +2181,8 @@ class DeviceConstraintPatchArgs:
|
|
|
1660
2181
|
def requests(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
1661
2182
|
"""
|
|
1662
2183
|
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.
|
|
2184
|
+
|
|
2185
|
+
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.
|
|
1663
2186
|
"""
|
|
1664
2187
|
return pulumi.get(self, "requests")
|
|
1665
2188
|
|
|
@@ -1684,6 +2207,8 @@ if not MYPY:
|
|
|
1684
2207
|
requests: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
|
|
1685
2208
|
"""
|
|
1686
2209
|
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.
|
|
2210
|
+
|
|
2211
|
+
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.
|
|
1687
2212
|
"""
|
|
1688
2213
|
elif False:
|
|
1689
2214
|
DeviceConstraintArgsDict: TypeAlias = Mapping[str, Any]
|
|
@@ -1701,6 +2226,8 @@ class DeviceConstraintArgs:
|
|
|
1701
2226
|
|
|
1702
2227
|
Must include the domain qualifier.
|
|
1703
2228
|
: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.
|
|
2229
|
+
|
|
2230
|
+
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.
|
|
1704
2231
|
"""
|
|
1705
2232
|
if match_attribute is not None:
|
|
1706
2233
|
pulumi.set(__self__, "match_attribute", match_attribute)
|
|
@@ -1728,6 +2255,8 @@ class DeviceConstraintArgs:
|
|
|
1728
2255
|
def requests(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
1729
2256
|
"""
|
|
1730
2257
|
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.
|
|
2258
|
+
|
|
2259
|
+
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.
|
|
1731
2260
|
"""
|
|
1732
2261
|
return pulumi.get(self, "requests")
|
|
1733
2262
|
|
|
@@ -1736,6 +2265,128 @@ class DeviceConstraintArgs:
|
|
|
1736
2265
|
pulumi.set(self, "requests", value)
|
|
1737
2266
|
|
|
1738
2267
|
|
|
2268
|
+
if not MYPY:
|
|
2269
|
+
class DeviceCounterConsumptionPatchArgsDict(TypedDict):
|
|
2270
|
+
"""
|
|
2271
|
+
DeviceCounterConsumption defines a set of counters that a device will consume from a CounterSet.
|
|
2272
|
+
"""
|
|
2273
|
+
counter_set: NotRequired[pulumi.Input[builtins.str]]
|
|
2274
|
+
"""
|
|
2275
|
+
CounterSet defines the set from which the counters defined will be consumed.
|
|
2276
|
+
"""
|
|
2277
|
+
counters: NotRequired[pulumi.Input[Mapping[str, pulumi.Input['CounterArgsDict']]]]
|
|
2278
|
+
"""
|
|
2279
|
+
Counters defines the Counter that will be consumed by the device.
|
|
2280
|
+
|
|
2281
|
+
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).
|
|
2282
|
+
"""
|
|
2283
|
+
elif False:
|
|
2284
|
+
DeviceCounterConsumptionPatchArgsDict: TypeAlias = Mapping[str, Any]
|
|
2285
|
+
|
|
2286
|
+
@pulumi.input_type
|
|
2287
|
+
class DeviceCounterConsumptionPatchArgs:
|
|
2288
|
+
def __init__(__self__, *,
|
|
2289
|
+
counter_set: Optional[pulumi.Input[builtins.str]] = None,
|
|
2290
|
+
counters: Optional[pulumi.Input[Mapping[str, pulumi.Input['CounterArgs']]]] = None):
|
|
2291
|
+
"""
|
|
2292
|
+
DeviceCounterConsumption defines a set of counters that a device will consume from a CounterSet.
|
|
2293
|
+
:param pulumi.Input[builtins.str] counter_set: CounterSet defines the set from which the counters defined will be consumed.
|
|
2294
|
+
:param pulumi.Input[Mapping[str, pulumi.Input['CounterArgs']]] counters: Counters defines the Counter that will be consumed by the device.
|
|
2295
|
+
|
|
2296
|
+
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).
|
|
2297
|
+
"""
|
|
2298
|
+
if counter_set is not None:
|
|
2299
|
+
pulumi.set(__self__, "counter_set", counter_set)
|
|
2300
|
+
if counters is not None:
|
|
2301
|
+
pulumi.set(__self__, "counters", counters)
|
|
2302
|
+
|
|
2303
|
+
@property
|
|
2304
|
+
@pulumi.getter(name="counterSet")
|
|
2305
|
+
def counter_set(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
2306
|
+
"""
|
|
2307
|
+
CounterSet defines the set from which the counters defined will be consumed.
|
|
2308
|
+
"""
|
|
2309
|
+
return pulumi.get(self, "counter_set")
|
|
2310
|
+
|
|
2311
|
+
@counter_set.setter
|
|
2312
|
+
def counter_set(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
2313
|
+
pulumi.set(self, "counter_set", value)
|
|
2314
|
+
|
|
2315
|
+
@property
|
|
2316
|
+
@pulumi.getter
|
|
2317
|
+
def counters(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input['CounterArgs']]]]:
|
|
2318
|
+
"""
|
|
2319
|
+
Counters defines the Counter that will be consumed by the device.
|
|
2320
|
+
|
|
2321
|
+
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).
|
|
2322
|
+
"""
|
|
2323
|
+
return pulumi.get(self, "counters")
|
|
2324
|
+
|
|
2325
|
+
@counters.setter
|
|
2326
|
+
def counters(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input['CounterArgs']]]]):
|
|
2327
|
+
pulumi.set(self, "counters", value)
|
|
2328
|
+
|
|
2329
|
+
|
|
2330
|
+
if not MYPY:
|
|
2331
|
+
class DeviceCounterConsumptionArgsDict(TypedDict):
|
|
2332
|
+
"""
|
|
2333
|
+
DeviceCounterConsumption defines a set of counters that a device will consume from a CounterSet.
|
|
2334
|
+
"""
|
|
2335
|
+
counter_set: pulumi.Input[builtins.str]
|
|
2336
|
+
"""
|
|
2337
|
+
CounterSet defines the set from which the counters defined will be consumed.
|
|
2338
|
+
"""
|
|
2339
|
+
counters: pulumi.Input[Mapping[str, pulumi.Input['CounterArgsDict']]]
|
|
2340
|
+
"""
|
|
2341
|
+
Counters defines the Counter that will be consumed by the device.
|
|
2342
|
+
|
|
2343
|
+
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).
|
|
2344
|
+
"""
|
|
2345
|
+
elif False:
|
|
2346
|
+
DeviceCounterConsumptionArgsDict: TypeAlias = Mapping[str, Any]
|
|
2347
|
+
|
|
2348
|
+
@pulumi.input_type
|
|
2349
|
+
class DeviceCounterConsumptionArgs:
|
|
2350
|
+
def __init__(__self__, *,
|
|
2351
|
+
counter_set: pulumi.Input[builtins.str],
|
|
2352
|
+
counters: pulumi.Input[Mapping[str, pulumi.Input['CounterArgs']]]):
|
|
2353
|
+
"""
|
|
2354
|
+
DeviceCounterConsumption defines a set of counters that a device will consume from a CounterSet.
|
|
2355
|
+
:param pulumi.Input[builtins.str] counter_set: CounterSet defines the set from which the counters defined will be consumed.
|
|
2356
|
+
:param pulumi.Input[Mapping[str, pulumi.Input['CounterArgs']]] counters: Counters defines the Counter that will be consumed by the device.
|
|
2357
|
+
|
|
2358
|
+
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).
|
|
2359
|
+
"""
|
|
2360
|
+
pulumi.set(__self__, "counter_set", counter_set)
|
|
2361
|
+
pulumi.set(__self__, "counters", counters)
|
|
2362
|
+
|
|
2363
|
+
@property
|
|
2364
|
+
@pulumi.getter(name="counterSet")
|
|
2365
|
+
def counter_set(self) -> pulumi.Input[builtins.str]:
|
|
2366
|
+
"""
|
|
2367
|
+
CounterSet defines the set from which the counters defined will be consumed.
|
|
2368
|
+
"""
|
|
2369
|
+
return pulumi.get(self, "counter_set")
|
|
2370
|
+
|
|
2371
|
+
@counter_set.setter
|
|
2372
|
+
def counter_set(self, value: pulumi.Input[builtins.str]):
|
|
2373
|
+
pulumi.set(self, "counter_set", value)
|
|
2374
|
+
|
|
2375
|
+
@property
|
|
2376
|
+
@pulumi.getter
|
|
2377
|
+
def counters(self) -> pulumi.Input[Mapping[str, pulumi.Input['CounterArgs']]]:
|
|
2378
|
+
"""
|
|
2379
|
+
Counters defines the Counter that will be consumed by the device.
|
|
2380
|
+
|
|
2381
|
+
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).
|
|
2382
|
+
"""
|
|
2383
|
+
return pulumi.get(self, "counters")
|
|
2384
|
+
|
|
2385
|
+
@counters.setter
|
|
2386
|
+
def counters(self, value: pulumi.Input[Mapping[str, pulumi.Input['CounterArgs']]]):
|
|
2387
|
+
pulumi.set(self, "counters", value)
|
|
2388
|
+
|
|
2389
|
+
|
|
1739
2390
|
if not MYPY:
|
|
1740
2391
|
class DevicePatchArgsDict(TypedDict):
|
|
1741
2392
|
"""
|
|
@@ -1815,7 +2466,9 @@ if not MYPY:
|
|
|
1815
2466
|
"""
|
|
1816
2467
|
request: pulumi.Input[builtins.str]
|
|
1817
2468
|
"""
|
|
1818
|
-
Request is the name of the request in the claim which caused this device to be allocated.
|
|
2469
|
+
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>.
|
|
2470
|
+
|
|
2471
|
+
Multiple devices may have been allocated per request.
|
|
1819
2472
|
"""
|
|
1820
2473
|
admin_access: NotRequired[pulumi.Input[builtins.bool]]
|
|
1821
2474
|
"""
|
|
@@ -1823,6 +2476,14 @@ if not MYPY:
|
|
|
1823
2476
|
|
|
1824
2477
|
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.
|
|
1825
2478
|
"""
|
|
2479
|
+
tolerations: NotRequired[pulumi.Input[Sequence[pulumi.Input['DeviceTolerationArgsDict']]]]
|
|
2480
|
+
"""
|
|
2481
|
+
A copy of all tolerations specified in the request at the time when the device got allocated.
|
|
2482
|
+
|
|
2483
|
+
The maximum number of tolerations is 16.
|
|
2484
|
+
|
|
2485
|
+
This is an alpha field and requires enabling the DRADeviceTaints feature gate.
|
|
2486
|
+
"""
|
|
1826
2487
|
elif False:
|
|
1827
2488
|
DeviceRequestAllocationResultArgsDict: TypeAlias = Mapping[str, Any]
|
|
1828
2489
|
|
|
@@ -1833,7 +2494,8 @@ class DeviceRequestAllocationResultArgs:
|
|
|
1833
2494
|
driver: pulumi.Input[builtins.str],
|
|
1834
2495
|
pool: pulumi.Input[builtins.str],
|
|
1835
2496
|
request: pulumi.Input[builtins.str],
|
|
1836
|
-
admin_access: Optional[pulumi.Input[builtins.bool]] = None
|
|
2497
|
+
admin_access: Optional[pulumi.Input[builtins.bool]] = None,
|
|
2498
|
+
tolerations: Optional[pulumi.Input[Sequence[pulumi.Input['DeviceTolerationArgs']]]] = None):
|
|
1837
2499
|
"""
|
|
1838
2500
|
DeviceRequestAllocationResult contains the allocation result for one request.
|
|
1839
2501
|
: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.
|
|
@@ -1843,10 +2505,17 @@ class DeviceRequestAllocationResultArgs:
|
|
|
1843
2505
|
: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>`).
|
|
1844
2506
|
|
|
1845
2507
|
Must not be longer than 253 characters and may contain one or more DNS sub-domains separated by slashes.
|
|
1846
|
-
:param pulumi.Input[builtins.str] request: Request is the name of the request in the claim which caused this device to be allocated.
|
|
2508
|
+
: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>.
|
|
2509
|
+
|
|
2510
|
+
Multiple devices may have been allocated per request.
|
|
1847
2511
|
: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.
|
|
1848
2512
|
|
|
1849
2513
|
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.
|
|
2514
|
+
: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.
|
|
2515
|
+
|
|
2516
|
+
The maximum number of tolerations is 16.
|
|
2517
|
+
|
|
2518
|
+
This is an alpha field and requires enabling the DRADeviceTaints feature gate.
|
|
1850
2519
|
"""
|
|
1851
2520
|
pulumi.set(__self__, "device", device)
|
|
1852
2521
|
pulumi.set(__self__, "driver", driver)
|
|
@@ -1854,6 +2523,8 @@ class DeviceRequestAllocationResultArgs:
|
|
|
1854
2523
|
pulumi.set(__self__, "request", request)
|
|
1855
2524
|
if admin_access is not None:
|
|
1856
2525
|
pulumi.set(__self__, "admin_access", admin_access)
|
|
2526
|
+
if tolerations is not None:
|
|
2527
|
+
pulumi.set(__self__, "tolerations", tolerations)
|
|
1857
2528
|
|
|
1858
2529
|
@property
|
|
1859
2530
|
@pulumi.getter
|
|
@@ -1899,7 +2570,9 @@ class DeviceRequestAllocationResultArgs:
|
|
|
1899
2570
|
@pulumi.getter
|
|
1900
2571
|
def request(self) -> pulumi.Input[builtins.str]:
|
|
1901
2572
|
"""
|
|
1902
|
-
Request is the name of the request in the claim which caused this device to be allocated.
|
|
2573
|
+
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>.
|
|
2574
|
+
|
|
2575
|
+
Multiple devices may have been allocated per request.
|
|
1903
2576
|
"""
|
|
1904
2577
|
return pulumi.get(self, "request")
|
|
1905
2578
|
|
|
@@ -1921,18 +2594,34 @@ class DeviceRequestAllocationResultArgs:
|
|
|
1921
2594
|
def admin_access(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
1922
2595
|
pulumi.set(self, "admin_access", value)
|
|
1923
2596
|
|
|
2597
|
+
@property
|
|
2598
|
+
@pulumi.getter
|
|
2599
|
+
def tolerations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DeviceTolerationArgs']]]]:
|
|
2600
|
+
"""
|
|
2601
|
+
A copy of all tolerations specified in the request at the time when the device got allocated.
|
|
2602
|
+
|
|
2603
|
+
The maximum number of tolerations is 16.
|
|
2604
|
+
|
|
2605
|
+
This is an alpha field and requires enabling the DRADeviceTaints feature gate.
|
|
2606
|
+
"""
|
|
2607
|
+
return pulumi.get(self, "tolerations")
|
|
2608
|
+
|
|
2609
|
+
@tolerations.setter
|
|
2610
|
+
def tolerations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DeviceTolerationArgs']]]]):
|
|
2611
|
+
pulumi.set(self, "tolerations", value)
|
|
2612
|
+
|
|
1924
2613
|
|
|
1925
2614
|
if not MYPY:
|
|
1926
2615
|
class DeviceRequestPatchArgsDict(TypedDict):
|
|
1927
2616
|
"""
|
|
1928
2617
|
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.
|
|
1929
|
-
|
|
1930
|
-
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.
|
|
1931
2618
|
"""
|
|
1932
2619
|
admin_access: NotRequired[pulumi.Input[builtins.bool]]
|
|
1933
2620
|
"""
|
|
1934
2621
|
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.
|
|
1935
2622
|
|
|
2623
|
+
This field can only be set when deviceClassName is set and no subrequests are specified in the firstAvailable list.
|
|
2624
|
+
|
|
1936
2625
|
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.
|
|
1937
2626
|
"""
|
|
1938
2627
|
allocation_mode: NotRequired[pulumi.Input[builtins.str]]
|
|
@@ -1944,25 +2633,38 @@ if not MYPY:
|
|
|
1944
2633
|
count field.
|
|
1945
2634
|
|
|
1946
2635
|
- All: This request is for all of the matching devices in a pool.
|
|
2636
|
+
At least one device must exist on the node for the allocation to succeed.
|
|
1947
2637
|
Allocation will fail if some devices are already allocated,
|
|
1948
2638
|
unless adminAccess is requested.
|
|
1949
2639
|
|
|
1950
|
-
If
|
|
2640
|
+
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.
|
|
2641
|
+
|
|
2642
|
+
This field can only be set when deviceClassName is set and no subrequests are specified in the firstAvailable list.
|
|
1951
2643
|
|
|
1952
2644
|
More modes may get added in the future. Clients must refuse to handle requests with unknown modes.
|
|
1953
2645
|
"""
|
|
1954
2646
|
count: NotRequired[pulumi.Input[builtins.int]]
|
|
1955
2647
|
"""
|
|
1956
2648
|
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.
|
|
2649
|
+
|
|
2650
|
+
This field can only be set when deviceClassName is set and no subrequests are specified in the firstAvailable list.
|
|
1957
2651
|
"""
|
|
1958
2652
|
device_class_name: NotRequired[pulumi.Input[builtins.str]]
|
|
1959
2653
|
"""
|
|
1960
2654
|
DeviceClassName references a specific DeviceClass, which can define additional configuration and selectors to be inherited by this request.
|
|
1961
2655
|
|
|
1962
|
-
A class is required. Which classes are available depends on the cluster.
|
|
2656
|
+
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.
|
|
1963
2657
|
|
|
1964
2658
|
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.
|
|
1965
2659
|
"""
|
|
2660
|
+
first_available: NotRequired[pulumi.Input[Sequence[pulumi.Input['DeviceSubRequestPatchArgsDict']]]]
|
|
2661
|
+
"""
|
|
2662
|
+
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.
|
|
2663
|
+
|
|
2664
|
+
This field may only be set in the entries of DeviceClaim.Requests.
|
|
2665
|
+
|
|
2666
|
+
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.
|
|
2667
|
+
"""
|
|
1966
2668
|
name: NotRequired[pulumi.Input[builtins.str]]
|
|
1967
2669
|
"""
|
|
1968
2670
|
Name can be used to reference this request in a pod.spec.containers[].resources.claims entry and in a constraint of the claim.
|
|
@@ -1972,6 +2674,22 @@ if not MYPY:
|
|
|
1972
2674
|
selectors: NotRequired[pulumi.Input[Sequence[pulumi.Input['DeviceSelectorPatchArgsDict']]]]
|
|
1973
2675
|
"""
|
|
1974
2676
|
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.
|
|
2677
|
+
|
|
2678
|
+
This field can only be set when deviceClassName is set and no subrequests are specified in the firstAvailable list.
|
|
2679
|
+
"""
|
|
2680
|
+
tolerations: NotRequired[pulumi.Input[Sequence[pulumi.Input['DeviceTolerationPatchArgsDict']]]]
|
|
2681
|
+
"""
|
|
2682
|
+
If specified, the request's tolerations.
|
|
2683
|
+
|
|
2684
|
+
Tolerations for NoSchedule are required to allocate a device which has a taint with that effect. The same applies to NoExecute.
|
|
2685
|
+
|
|
2686
|
+
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.
|
|
2687
|
+
|
|
2688
|
+
The maximum number of tolerations is 16.
|
|
2689
|
+
|
|
2690
|
+
This field can only be set when deviceClassName is set and no subrequests are specified in the firstAvailable list.
|
|
2691
|
+
|
|
2692
|
+
This is an alpha field and requires enabling the DRADeviceTaints feature gate.
|
|
1975
2693
|
"""
|
|
1976
2694
|
elif False:
|
|
1977
2695
|
DeviceRequestPatchArgsDict: TypeAlias = Mapping[str, Any]
|
|
@@ -1983,14 +2701,16 @@ class DeviceRequestPatchArgs:
|
|
|
1983
2701
|
allocation_mode: Optional[pulumi.Input[builtins.str]] = None,
|
|
1984
2702
|
count: Optional[pulumi.Input[builtins.int]] = None,
|
|
1985
2703
|
device_class_name: Optional[pulumi.Input[builtins.str]] = None,
|
|
2704
|
+
first_available: Optional[pulumi.Input[Sequence[pulumi.Input['DeviceSubRequestPatchArgs']]]] = None,
|
|
1986
2705
|
name: Optional[pulumi.Input[builtins.str]] = None,
|
|
1987
|
-
selectors: Optional[pulumi.Input[Sequence[pulumi.Input['DeviceSelectorPatchArgs']]]] = None
|
|
2706
|
+
selectors: Optional[pulumi.Input[Sequence[pulumi.Input['DeviceSelectorPatchArgs']]]] = None,
|
|
2707
|
+
tolerations: Optional[pulumi.Input[Sequence[pulumi.Input['DeviceTolerationPatchArgs']]]] = None):
|
|
1988
2708
|
"""
|
|
1989
2709
|
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.
|
|
1990
|
-
|
|
1991
|
-
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.
|
|
1992
2710
|
: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.
|
|
1993
2711
|
|
|
2712
|
+
This field can only be set when deviceClassName is set and no subrequests are specified in the firstAvailable list.
|
|
2713
|
+
|
|
1994
2714
|
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.
|
|
1995
2715
|
:param pulumi.Input[builtins.str] allocation_mode: AllocationMode and its related fields define how devices are allocated to satisfy this request. Supported values are:
|
|
1996
2716
|
|
|
@@ -1999,22 +2719,45 @@ class DeviceRequestPatchArgs:
|
|
|
1999
2719
|
count field.
|
|
2000
2720
|
|
|
2001
2721
|
- All: This request is for all of the matching devices in a pool.
|
|
2722
|
+
At least one device must exist on the node for the allocation to succeed.
|
|
2002
2723
|
Allocation will fail if some devices are already allocated,
|
|
2003
2724
|
unless adminAccess is requested.
|
|
2004
2725
|
|
|
2005
|
-
If
|
|
2726
|
+
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.
|
|
2727
|
+
|
|
2728
|
+
This field can only be set when deviceClassName is set and no subrequests are specified in the firstAvailable list.
|
|
2006
2729
|
|
|
2007
2730
|
More modes may get added in the future. Clients must refuse to handle requests with unknown modes.
|
|
2008
2731
|
: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.
|
|
2732
|
+
|
|
2733
|
+
This field can only be set when deviceClassName is set and no subrequests are specified in the firstAvailable list.
|
|
2009
2734
|
: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.
|
|
2010
2735
|
|
|
2011
|
-
A class is required. Which classes are available depends on the cluster.
|
|
2736
|
+
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.
|
|
2012
2737
|
|
|
2013
2738
|
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.
|
|
2739
|
+
: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.
|
|
2740
|
+
|
|
2741
|
+
This field may only be set in the entries of DeviceClaim.Requests.
|
|
2742
|
+
|
|
2743
|
+
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.
|
|
2014
2744
|
: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.
|
|
2015
2745
|
|
|
2016
2746
|
Must be a DNS label.
|
|
2017
2747
|
: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.
|
|
2748
|
+
|
|
2749
|
+
This field can only be set when deviceClassName is set and no subrequests are specified in the firstAvailable list.
|
|
2750
|
+
:param pulumi.Input[Sequence[pulumi.Input['DeviceTolerationPatchArgs']]] tolerations: If specified, the request's tolerations.
|
|
2751
|
+
|
|
2752
|
+
Tolerations for NoSchedule are required to allocate a device which has a taint with that effect. The same applies to NoExecute.
|
|
2753
|
+
|
|
2754
|
+
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.
|
|
2755
|
+
|
|
2756
|
+
The maximum number of tolerations is 16.
|
|
2757
|
+
|
|
2758
|
+
This field can only be set when deviceClassName is set and no subrequests are specified in the firstAvailable list.
|
|
2759
|
+
|
|
2760
|
+
This is an alpha field and requires enabling the DRADeviceTaints feature gate.
|
|
2018
2761
|
"""
|
|
2019
2762
|
if admin_access is not None:
|
|
2020
2763
|
pulumi.set(__self__, "admin_access", admin_access)
|
|
@@ -2024,10 +2767,14 @@ class DeviceRequestPatchArgs:
|
|
|
2024
2767
|
pulumi.set(__self__, "count", count)
|
|
2025
2768
|
if device_class_name is not None:
|
|
2026
2769
|
pulumi.set(__self__, "device_class_name", device_class_name)
|
|
2770
|
+
if first_available is not None:
|
|
2771
|
+
pulumi.set(__self__, "first_available", first_available)
|
|
2027
2772
|
if name is not None:
|
|
2028
2773
|
pulumi.set(__self__, "name", name)
|
|
2029
2774
|
if selectors is not None:
|
|
2030
2775
|
pulumi.set(__self__, "selectors", selectors)
|
|
2776
|
+
if tolerations is not None:
|
|
2777
|
+
pulumi.set(__self__, "tolerations", tolerations)
|
|
2031
2778
|
|
|
2032
2779
|
@property
|
|
2033
2780
|
@pulumi.getter(name="adminAccess")
|
|
@@ -2035,6 +2782,8 @@ class DeviceRequestPatchArgs:
|
|
|
2035
2782
|
"""
|
|
2036
2783
|
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.
|
|
2037
2784
|
|
|
2785
|
+
This field can only be set when deviceClassName is set and no subrequests are specified in the firstAvailable list.
|
|
2786
|
+
|
|
2038
2787
|
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.
|
|
2039
2788
|
"""
|
|
2040
2789
|
return pulumi.get(self, "admin_access")
|
|
@@ -2054,10 +2803,13 @@ class DeviceRequestPatchArgs:
|
|
|
2054
2803
|
count field.
|
|
2055
2804
|
|
|
2056
2805
|
- All: This request is for all of the matching devices in a pool.
|
|
2806
|
+
At least one device must exist on the node for the allocation to succeed.
|
|
2057
2807
|
Allocation will fail if some devices are already allocated,
|
|
2058
2808
|
unless adminAccess is requested.
|
|
2059
2809
|
|
|
2060
|
-
If
|
|
2810
|
+
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.
|
|
2811
|
+
|
|
2812
|
+
This field can only be set when deviceClassName is set and no subrequests are specified in the firstAvailable list.
|
|
2061
2813
|
|
|
2062
2814
|
More modes may get added in the future. Clients must refuse to handle requests with unknown modes.
|
|
2063
2815
|
"""
|
|
@@ -2072,6 +2824,8 @@ class DeviceRequestPatchArgs:
|
|
|
2072
2824
|
def count(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
2073
2825
|
"""
|
|
2074
2826
|
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.
|
|
2827
|
+
|
|
2828
|
+
This field can only be set when deviceClassName is set and no subrequests are specified in the firstAvailable list.
|
|
2075
2829
|
"""
|
|
2076
2830
|
return pulumi.get(self, "count")
|
|
2077
2831
|
|
|
@@ -2085,7 +2839,7 @@ class DeviceRequestPatchArgs:
|
|
|
2085
2839
|
"""
|
|
2086
2840
|
DeviceClassName references a specific DeviceClass, which can define additional configuration and selectors to be inherited by this request.
|
|
2087
2841
|
|
|
2088
|
-
A class is required. Which classes are available depends on the cluster.
|
|
2842
|
+
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.
|
|
2089
2843
|
|
|
2090
2844
|
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.
|
|
2091
2845
|
"""
|
|
@@ -2095,6 +2849,22 @@ class DeviceRequestPatchArgs:
|
|
|
2095
2849
|
def device_class_name(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
2096
2850
|
pulumi.set(self, "device_class_name", value)
|
|
2097
2851
|
|
|
2852
|
+
@property
|
|
2853
|
+
@pulumi.getter(name="firstAvailable")
|
|
2854
|
+
def first_available(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DeviceSubRequestPatchArgs']]]]:
|
|
2855
|
+
"""
|
|
2856
|
+
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.
|
|
2857
|
+
|
|
2858
|
+
This field may only be set in the entries of DeviceClaim.Requests.
|
|
2859
|
+
|
|
2860
|
+
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.
|
|
2861
|
+
"""
|
|
2862
|
+
return pulumi.get(self, "first_available")
|
|
2863
|
+
|
|
2864
|
+
@first_available.setter
|
|
2865
|
+
def first_available(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DeviceSubRequestPatchArgs']]]]):
|
|
2866
|
+
pulumi.set(self, "first_available", value)
|
|
2867
|
+
|
|
2098
2868
|
@property
|
|
2099
2869
|
@pulumi.getter
|
|
2100
2870
|
def name(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
@@ -2114,6 +2884,8 @@ class DeviceRequestPatchArgs:
|
|
|
2114
2884
|
def selectors(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DeviceSelectorPatchArgs']]]]:
|
|
2115
2885
|
"""
|
|
2116
2886
|
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.
|
|
2887
|
+
|
|
2888
|
+
This field can only be set when deviceClassName is set and no subrequests are specified in the firstAvailable list.
|
|
2117
2889
|
"""
|
|
2118
2890
|
return pulumi.get(self, "selectors")
|
|
2119
2891
|
|
|
@@ -2121,21 +2893,33 @@ class DeviceRequestPatchArgs:
|
|
|
2121
2893
|
def selectors(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DeviceSelectorPatchArgs']]]]):
|
|
2122
2894
|
pulumi.set(self, "selectors", value)
|
|
2123
2895
|
|
|
2124
|
-
|
|
2125
|
-
|
|
2126
|
-
|
|
2896
|
+
@property
|
|
2897
|
+
@pulumi.getter
|
|
2898
|
+
def tolerations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DeviceTolerationPatchArgs']]]]:
|
|
2127
2899
|
"""
|
|
2128
|
-
|
|
2900
|
+
If specified, the request's tolerations.
|
|
2129
2901
|
|
|
2130
|
-
|
|
2131
|
-
|
|
2132
|
-
|
|
2902
|
+
Tolerations for NoSchedule are required to allocate a device which has a taint with that effect. The same applies to NoExecute.
|
|
2903
|
+
|
|
2904
|
+
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.
|
|
2905
|
+
|
|
2906
|
+
The maximum number of tolerations is 16.
|
|
2907
|
+
|
|
2908
|
+
This field can only be set when deviceClassName is set and no subrequests are specified in the firstAvailable list.
|
|
2909
|
+
|
|
2910
|
+
This is an alpha field and requires enabling the DRADeviceTaints feature gate.
|
|
2133
2911
|
"""
|
|
2134
|
-
|
|
2912
|
+
return pulumi.get(self, "tolerations")
|
|
2135
2913
|
|
|
2136
|
-
|
|
2914
|
+
@tolerations.setter
|
|
2915
|
+
def tolerations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DeviceTolerationPatchArgs']]]]):
|
|
2916
|
+
pulumi.set(self, "tolerations", value)
|
|
2137
2917
|
|
|
2138
|
-
|
|
2918
|
+
|
|
2919
|
+
if not MYPY:
|
|
2920
|
+
class DeviceRequestArgsDict(TypedDict):
|
|
2921
|
+
"""
|
|
2922
|
+
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.
|
|
2139
2923
|
"""
|
|
2140
2924
|
name: pulumi.Input[builtins.str]
|
|
2141
2925
|
"""
|
|
@@ -2147,6 +2931,8 @@ if not MYPY:
|
|
|
2147
2931
|
"""
|
|
2148
2932
|
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.
|
|
2149
2933
|
|
|
2934
|
+
This field can only be set when deviceClassName is set and no subrequests are specified in the firstAvailable list.
|
|
2935
|
+
|
|
2150
2936
|
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.
|
|
2151
2937
|
"""
|
|
2152
2938
|
allocation_mode: NotRequired[pulumi.Input[builtins.str]]
|
|
@@ -2158,20 +2944,57 @@ if not MYPY:
|
|
|
2158
2944
|
count field.
|
|
2159
2945
|
|
|
2160
2946
|
- All: This request is for all of the matching devices in a pool.
|
|
2947
|
+
At least one device must exist on the node for the allocation to succeed.
|
|
2161
2948
|
Allocation will fail if some devices are already allocated,
|
|
2162
2949
|
unless adminAccess is requested.
|
|
2163
2950
|
|
|
2164
|
-
If
|
|
2951
|
+
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.
|
|
2952
|
+
|
|
2953
|
+
This field can only be set when deviceClassName is set and no subrequests are specified in the firstAvailable list.
|
|
2165
2954
|
|
|
2166
2955
|
More modes may get added in the future. Clients must refuse to handle requests with unknown modes.
|
|
2167
2956
|
"""
|
|
2168
2957
|
count: NotRequired[pulumi.Input[builtins.int]]
|
|
2169
2958
|
"""
|
|
2170
2959
|
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.
|
|
2960
|
+
|
|
2961
|
+
This field can only be set when deviceClassName is set and no subrequests are specified in the firstAvailable list.
|
|
2962
|
+
"""
|
|
2963
|
+
device_class_name: NotRequired[pulumi.Input[builtins.str]]
|
|
2964
|
+
"""
|
|
2965
|
+
DeviceClassName references a specific DeviceClass, which can define additional configuration and selectors to be inherited by this request.
|
|
2966
|
+
|
|
2967
|
+
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.
|
|
2968
|
+
|
|
2969
|
+
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.
|
|
2970
|
+
"""
|
|
2971
|
+
first_available: NotRequired[pulumi.Input[Sequence[pulumi.Input['DeviceSubRequestArgsDict']]]]
|
|
2972
|
+
"""
|
|
2973
|
+
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.
|
|
2974
|
+
|
|
2975
|
+
This field may only be set in the entries of DeviceClaim.Requests.
|
|
2976
|
+
|
|
2977
|
+
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.
|
|
2171
2978
|
"""
|
|
2172
2979
|
selectors: NotRequired[pulumi.Input[Sequence[pulumi.Input['DeviceSelectorArgsDict']]]]
|
|
2173
2980
|
"""
|
|
2174
2981
|
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.
|
|
2982
|
+
|
|
2983
|
+
This field can only be set when deviceClassName is set and no subrequests are specified in the firstAvailable list.
|
|
2984
|
+
"""
|
|
2985
|
+
tolerations: NotRequired[pulumi.Input[Sequence[pulumi.Input['DeviceTolerationArgsDict']]]]
|
|
2986
|
+
"""
|
|
2987
|
+
If specified, the request's tolerations.
|
|
2988
|
+
|
|
2989
|
+
Tolerations for NoSchedule are required to allocate a device which has a taint with that effect. The same applies to NoExecute.
|
|
2990
|
+
|
|
2991
|
+
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.
|
|
2992
|
+
|
|
2993
|
+
The maximum number of tolerations is 16.
|
|
2994
|
+
|
|
2995
|
+
This field can only be set when deviceClassName is set and no subrequests are specified in the firstAvailable list.
|
|
2996
|
+
|
|
2997
|
+
This is an alpha field and requires enabling the DRADeviceTaints feature gate.
|
|
2175
2998
|
"""
|
|
2176
2999
|
elif False:
|
|
2177
3000
|
DeviceRequestArgsDict: TypeAlias = Mapping[str, Any]
|
|
@@ -2179,26 +3002,23 @@ elif False:
|
|
|
2179
3002
|
@pulumi.input_type
|
|
2180
3003
|
class DeviceRequestArgs:
|
|
2181
3004
|
def __init__(__self__, *,
|
|
2182
|
-
device_class_name: pulumi.Input[builtins.str],
|
|
2183
3005
|
name: pulumi.Input[builtins.str],
|
|
2184
3006
|
admin_access: Optional[pulumi.Input[builtins.bool]] = None,
|
|
2185
3007
|
allocation_mode: Optional[pulumi.Input[builtins.str]] = None,
|
|
2186
3008
|
count: Optional[pulumi.Input[builtins.int]] = None,
|
|
2187
|
-
|
|
3009
|
+
device_class_name: Optional[pulumi.Input[builtins.str]] = None,
|
|
3010
|
+
first_available: Optional[pulumi.Input[Sequence[pulumi.Input['DeviceSubRequestArgs']]]] = None,
|
|
3011
|
+
selectors: Optional[pulumi.Input[Sequence[pulumi.Input['DeviceSelectorArgs']]]] = None,
|
|
3012
|
+
tolerations: Optional[pulumi.Input[Sequence[pulumi.Input['DeviceTolerationArgs']]]] = None):
|
|
2188
3013
|
"""
|
|
2189
3014
|
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.
|
|
2190
|
-
|
|
2191
|
-
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.
|
|
2192
|
-
: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.
|
|
2193
|
-
|
|
2194
|
-
A class is required. Which classes are available depends on the cluster.
|
|
2195
|
-
|
|
2196
|
-
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.
|
|
2197
3015
|
: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.
|
|
2198
3016
|
|
|
2199
3017
|
Must be a DNS label.
|
|
2200
3018
|
: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.
|
|
2201
3019
|
|
|
3020
|
+
This field can only be set when deviceClassName is set and no subrequests are specified in the firstAvailable list.
|
|
3021
|
+
|
|
2202
3022
|
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.
|
|
2203
3023
|
:param pulumi.Input[builtins.str] allocation_mode: AllocationMode and its related fields define how devices are allocated to satisfy this request. Supported values are:
|
|
2204
3024
|
|
|
@@ -2207,189 +3027,1593 @@ class DeviceRequestArgs:
|
|
|
2207
3027
|
count field.
|
|
2208
3028
|
|
|
2209
3029
|
- All: This request is for all of the matching devices in a pool.
|
|
3030
|
+
At least one device must exist on the node for the allocation to succeed.
|
|
2210
3031
|
Allocation will fail if some devices are already allocated,
|
|
2211
3032
|
unless adminAccess is requested.
|
|
2212
3033
|
|
|
2213
|
-
If
|
|
3034
|
+
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.
|
|
3035
|
+
|
|
3036
|
+
This field can only be set when deviceClassName is set and no subrequests are specified in the firstAvailable list.
|
|
2214
3037
|
|
|
2215
3038
|
More modes may get added in the future. Clients must refuse to handle requests with unknown modes.
|
|
2216
3039
|
: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.
|
|
3040
|
+
|
|
3041
|
+
This field can only be set when deviceClassName is set and no subrequests are specified in the firstAvailable list.
|
|
3042
|
+
: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.
|
|
3043
|
+
|
|
3044
|
+
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.
|
|
3045
|
+
|
|
3046
|
+
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.
|
|
3047
|
+
: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.
|
|
3048
|
+
|
|
3049
|
+
This field may only be set in the entries of DeviceClaim.Requests.
|
|
3050
|
+
|
|
3051
|
+
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.
|
|
2217
3052
|
: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.
|
|
3053
|
+
|
|
3054
|
+
This field can only be set when deviceClassName is set and no subrequests are specified in the firstAvailable list.
|
|
3055
|
+
:param pulumi.Input[Sequence[pulumi.Input['DeviceTolerationArgs']]] tolerations: If specified, the request's tolerations.
|
|
3056
|
+
|
|
3057
|
+
Tolerations for NoSchedule are required to allocate a device which has a taint with that effect. The same applies to NoExecute.
|
|
3058
|
+
|
|
3059
|
+
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.
|
|
3060
|
+
|
|
3061
|
+
The maximum number of tolerations is 16.
|
|
3062
|
+
|
|
3063
|
+
This field can only be set when deviceClassName is set and no subrequests are specified in the firstAvailable list.
|
|
3064
|
+
|
|
3065
|
+
This is an alpha field and requires enabling the DRADeviceTaints feature gate.
|
|
3066
|
+
"""
|
|
3067
|
+
pulumi.set(__self__, "name", name)
|
|
3068
|
+
if admin_access is not None:
|
|
3069
|
+
pulumi.set(__self__, "admin_access", admin_access)
|
|
3070
|
+
if allocation_mode is not None:
|
|
3071
|
+
pulumi.set(__self__, "allocation_mode", allocation_mode)
|
|
3072
|
+
if count is not None:
|
|
3073
|
+
pulumi.set(__self__, "count", count)
|
|
3074
|
+
if device_class_name is not None:
|
|
3075
|
+
pulumi.set(__self__, "device_class_name", device_class_name)
|
|
3076
|
+
if first_available is not None:
|
|
3077
|
+
pulumi.set(__self__, "first_available", first_available)
|
|
3078
|
+
if selectors is not None:
|
|
3079
|
+
pulumi.set(__self__, "selectors", selectors)
|
|
3080
|
+
if tolerations is not None:
|
|
3081
|
+
pulumi.set(__self__, "tolerations", tolerations)
|
|
3082
|
+
|
|
3083
|
+
@property
|
|
3084
|
+
@pulumi.getter
|
|
3085
|
+
def name(self) -> pulumi.Input[builtins.str]:
|
|
3086
|
+
"""
|
|
3087
|
+
Name can be used to reference this request in a pod.spec.containers[].resources.claims entry and in a constraint of the claim.
|
|
3088
|
+
|
|
3089
|
+
Must be a DNS label.
|
|
3090
|
+
"""
|
|
3091
|
+
return pulumi.get(self, "name")
|
|
3092
|
+
|
|
3093
|
+
@name.setter
|
|
3094
|
+
def name(self, value: pulumi.Input[builtins.str]):
|
|
3095
|
+
pulumi.set(self, "name", value)
|
|
3096
|
+
|
|
3097
|
+
@property
|
|
3098
|
+
@pulumi.getter(name="adminAccess")
|
|
3099
|
+
def admin_access(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
3100
|
+
"""
|
|
3101
|
+
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.
|
|
3102
|
+
|
|
3103
|
+
This field can only be set when deviceClassName is set and no subrequests are specified in the firstAvailable list.
|
|
3104
|
+
|
|
3105
|
+
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.
|
|
3106
|
+
"""
|
|
3107
|
+
return pulumi.get(self, "admin_access")
|
|
3108
|
+
|
|
3109
|
+
@admin_access.setter
|
|
3110
|
+
def admin_access(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
3111
|
+
pulumi.set(self, "admin_access", value)
|
|
3112
|
+
|
|
3113
|
+
@property
|
|
3114
|
+
@pulumi.getter(name="allocationMode")
|
|
3115
|
+
def allocation_mode(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
3116
|
+
"""
|
|
3117
|
+
AllocationMode and its related fields define how devices are allocated to satisfy this request. Supported values are:
|
|
3118
|
+
|
|
3119
|
+
- ExactCount: This request is for a specific number of devices.
|
|
3120
|
+
This is the default. The exact number is provided in the
|
|
3121
|
+
count field.
|
|
3122
|
+
|
|
3123
|
+
- All: This request is for all of the matching devices in a pool.
|
|
3124
|
+
At least one device must exist on the node for the allocation to succeed.
|
|
3125
|
+
Allocation will fail if some devices are already allocated,
|
|
3126
|
+
unless adminAccess is requested.
|
|
3127
|
+
|
|
3128
|
+
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.
|
|
3129
|
+
|
|
3130
|
+
This field can only be set when deviceClassName is set and no subrequests are specified in the firstAvailable list.
|
|
3131
|
+
|
|
3132
|
+
More modes may get added in the future. Clients must refuse to handle requests with unknown modes.
|
|
3133
|
+
"""
|
|
3134
|
+
return pulumi.get(self, "allocation_mode")
|
|
3135
|
+
|
|
3136
|
+
@allocation_mode.setter
|
|
3137
|
+
def allocation_mode(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
3138
|
+
pulumi.set(self, "allocation_mode", value)
|
|
3139
|
+
|
|
3140
|
+
@property
|
|
3141
|
+
@pulumi.getter
|
|
3142
|
+
def count(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
3143
|
+
"""
|
|
3144
|
+
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.
|
|
3145
|
+
|
|
3146
|
+
This field can only be set when deviceClassName is set and no subrequests are specified in the firstAvailable list.
|
|
3147
|
+
"""
|
|
3148
|
+
return pulumi.get(self, "count")
|
|
3149
|
+
|
|
3150
|
+
@count.setter
|
|
3151
|
+
def count(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
3152
|
+
pulumi.set(self, "count", value)
|
|
3153
|
+
|
|
3154
|
+
@property
|
|
3155
|
+
@pulumi.getter(name="deviceClassName")
|
|
3156
|
+
def device_class_name(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
3157
|
+
"""
|
|
3158
|
+
DeviceClassName references a specific DeviceClass, which can define additional configuration and selectors to be inherited by this request.
|
|
3159
|
+
|
|
3160
|
+
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.
|
|
3161
|
+
|
|
3162
|
+
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.
|
|
3163
|
+
"""
|
|
3164
|
+
return pulumi.get(self, "device_class_name")
|
|
3165
|
+
|
|
3166
|
+
@device_class_name.setter
|
|
3167
|
+
def device_class_name(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
3168
|
+
pulumi.set(self, "device_class_name", value)
|
|
3169
|
+
|
|
3170
|
+
@property
|
|
3171
|
+
@pulumi.getter(name="firstAvailable")
|
|
3172
|
+
def first_available(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DeviceSubRequestArgs']]]]:
|
|
3173
|
+
"""
|
|
3174
|
+
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.
|
|
3175
|
+
|
|
3176
|
+
This field may only be set in the entries of DeviceClaim.Requests.
|
|
3177
|
+
|
|
3178
|
+
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.
|
|
3179
|
+
"""
|
|
3180
|
+
return pulumi.get(self, "first_available")
|
|
3181
|
+
|
|
3182
|
+
@first_available.setter
|
|
3183
|
+
def first_available(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DeviceSubRequestArgs']]]]):
|
|
3184
|
+
pulumi.set(self, "first_available", value)
|
|
3185
|
+
|
|
3186
|
+
@property
|
|
3187
|
+
@pulumi.getter
|
|
3188
|
+
def selectors(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DeviceSelectorArgs']]]]:
|
|
3189
|
+
"""
|
|
3190
|
+
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.
|
|
3191
|
+
|
|
3192
|
+
This field can only be set when deviceClassName is set and no subrequests are specified in the firstAvailable list.
|
|
3193
|
+
"""
|
|
3194
|
+
return pulumi.get(self, "selectors")
|
|
3195
|
+
|
|
3196
|
+
@selectors.setter
|
|
3197
|
+
def selectors(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DeviceSelectorArgs']]]]):
|
|
3198
|
+
pulumi.set(self, "selectors", value)
|
|
3199
|
+
|
|
3200
|
+
@property
|
|
3201
|
+
@pulumi.getter
|
|
3202
|
+
def tolerations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DeviceTolerationArgs']]]]:
|
|
3203
|
+
"""
|
|
3204
|
+
If specified, the request's tolerations.
|
|
3205
|
+
|
|
3206
|
+
Tolerations for NoSchedule are required to allocate a device which has a taint with that effect. The same applies to NoExecute.
|
|
3207
|
+
|
|
3208
|
+
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.
|
|
3209
|
+
|
|
3210
|
+
The maximum number of tolerations is 16.
|
|
3211
|
+
|
|
3212
|
+
This field can only be set when deviceClassName is set and no subrequests are specified in the firstAvailable list.
|
|
3213
|
+
|
|
3214
|
+
This is an alpha field and requires enabling the DRADeviceTaints feature gate.
|
|
3215
|
+
"""
|
|
3216
|
+
return pulumi.get(self, "tolerations")
|
|
3217
|
+
|
|
3218
|
+
@tolerations.setter
|
|
3219
|
+
def tolerations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DeviceTolerationArgs']]]]):
|
|
3220
|
+
pulumi.set(self, "tolerations", value)
|
|
3221
|
+
|
|
3222
|
+
|
|
3223
|
+
if not MYPY:
|
|
3224
|
+
class DeviceSelectorPatchArgsDict(TypedDict):
|
|
3225
|
+
"""
|
|
3226
|
+
DeviceSelector must have exactly one field set.
|
|
3227
|
+
"""
|
|
3228
|
+
cel: NotRequired[pulumi.Input['CELDeviceSelectorPatchArgsDict']]
|
|
3229
|
+
"""
|
|
3230
|
+
CEL contains a CEL expression for selecting a device.
|
|
3231
|
+
"""
|
|
3232
|
+
elif False:
|
|
3233
|
+
DeviceSelectorPatchArgsDict: TypeAlias = Mapping[str, Any]
|
|
3234
|
+
|
|
3235
|
+
@pulumi.input_type
|
|
3236
|
+
class DeviceSelectorPatchArgs:
|
|
3237
|
+
def __init__(__self__, *,
|
|
3238
|
+
cel: Optional[pulumi.Input['CELDeviceSelectorPatchArgs']] = None):
|
|
3239
|
+
"""
|
|
3240
|
+
DeviceSelector must have exactly one field set.
|
|
3241
|
+
:param pulumi.Input['CELDeviceSelectorPatchArgs'] cel: CEL contains a CEL expression for selecting a device.
|
|
3242
|
+
"""
|
|
3243
|
+
if cel is not None:
|
|
3244
|
+
pulumi.set(__self__, "cel", cel)
|
|
3245
|
+
|
|
3246
|
+
@property
|
|
3247
|
+
@pulumi.getter
|
|
3248
|
+
def cel(self) -> Optional[pulumi.Input['CELDeviceSelectorPatchArgs']]:
|
|
3249
|
+
"""
|
|
3250
|
+
CEL contains a CEL expression for selecting a device.
|
|
3251
|
+
"""
|
|
3252
|
+
return pulumi.get(self, "cel")
|
|
3253
|
+
|
|
3254
|
+
@cel.setter
|
|
3255
|
+
def cel(self, value: Optional[pulumi.Input['CELDeviceSelectorPatchArgs']]):
|
|
3256
|
+
pulumi.set(self, "cel", value)
|
|
3257
|
+
|
|
3258
|
+
|
|
3259
|
+
if not MYPY:
|
|
3260
|
+
class DeviceSelectorArgsDict(TypedDict):
|
|
3261
|
+
"""
|
|
3262
|
+
DeviceSelector must have exactly one field set.
|
|
3263
|
+
"""
|
|
3264
|
+
cel: NotRequired[pulumi.Input['CELDeviceSelectorArgsDict']]
|
|
3265
|
+
"""
|
|
3266
|
+
CEL contains a CEL expression for selecting a device.
|
|
3267
|
+
"""
|
|
3268
|
+
elif False:
|
|
3269
|
+
DeviceSelectorArgsDict: TypeAlias = Mapping[str, Any]
|
|
3270
|
+
|
|
3271
|
+
@pulumi.input_type
|
|
3272
|
+
class DeviceSelectorArgs:
|
|
3273
|
+
def __init__(__self__, *,
|
|
3274
|
+
cel: Optional[pulumi.Input['CELDeviceSelectorArgs']] = None):
|
|
3275
|
+
"""
|
|
3276
|
+
DeviceSelector must have exactly one field set.
|
|
3277
|
+
:param pulumi.Input['CELDeviceSelectorArgs'] cel: CEL contains a CEL expression for selecting a device.
|
|
3278
|
+
"""
|
|
3279
|
+
if cel is not None:
|
|
3280
|
+
pulumi.set(__self__, "cel", cel)
|
|
3281
|
+
|
|
3282
|
+
@property
|
|
3283
|
+
@pulumi.getter
|
|
3284
|
+
def cel(self) -> Optional[pulumi.Input['CELDeviceSelectorArgs']]:
|
|
3285
|
+
"""
|
|
3286
|
+
CEL contains a CEL expression for selecting a device.
|
|
3287
|
+
"""
|
|
3288
|
+
return pulumi.get(self, "cel")
|
|
3289
|
+
|
|
3290
|
+
@cel.setter
|
|
3291
|
+
def cel(self, value: Optional[pulumi.Input['CELDeviceSelectorArgs']]):
|
|
3292
|
+
pulumi.set(self, "cel", value)
|
|
3293
|
+
|
|
3294
|
+
|
|
3295
|
+
if not MYPY:
|
|
3296
|
+
class DeviceSubRequestPatchArgsDict(TypedDict):
|
|
3297
|
+
"""
|
|
3298
|
+
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.
|
|
3299
|
+
|
|
3300
|
+
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.
|
|
3301
|
+
"""
|
|
3302
|
+
allocation_mode: NotRequired[pulumi.Input[builtins.str]]
|
|
3303
|
+
"""
|
|
3304
|
+
AllocationMode and its related fields define how devices are allocated to satisfy this request. Supported values are:
|
|
3305
|
+
|
|
3306
|
+
- ExactCount: This request is for a specific number of devices.
|
|
3307
|
+
This is the default. The exact number is provided in the
|
|
3308
|
+
count field.
|
|
3309
|
+
|
|
3310
|
+
- All: This request is for all of the matching devices in a pool.
|
|
3311
|
+
Allocation will fail if some devices are already allocated,
|
|
3312
|
+
unless adminAccess is requested.
|
|
3313
|
+
|
|
3314
|
+
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.
|
|
3315
|
+
|
|
3316
|
+
More modes may get added in the future. Clients must refuse to handle requests with unknown modes.
|
|
3317
|
+
"""
|
|
3318
|
+
count: NotRequired[pulumi.Input[builtins.int]]
|
|
3319
|
+
"""
|
|
3320
|
+
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.
|
|
3321
|
+
"""
|
|
3322
|
+
device_class_name: NotRequired[pulumi.Input[builtins.str]]
|
|
3323
|
+
"""
|
|
3324
|
+
DeviceClassName references a specific DeviceClass, which can define additional configuration and selectors to be inherited by this subrequest.
|
|
3325
|
+
|
|
3326
|
+
A class is required. Which classes are available depends on the cluster.
|
|
3327
|
+
|
|
3328
|
+
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.
|
|
3329
|
+
"""
|
|
3330
|
+
name: NotRequired[pulumi.Input[builtins.str]]
|
|
3331
|
+
"""
|
|
3332
|
+
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>.
|
|
3333
|
+
|
|
3334
|
+
Must be a DNS label.
|
|
3335
|
+
"""
|
|
3336
|
+
selectors: NotRequired[pulumi.Input[Sequence[pulumi.Input['DeviceSelectorPatchArgsDict']]]]
|
|
3337
|
+
"""
|
|
3338
|
+
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.
|
|
3339
|
+
"""
|
|
3340
|
+
tolerations: NotRequired[pulumi.Input[Sequence[pulumi.Input['DeviceTolerationPatchArgsDict']]]]
|
|
3341
|
+
"""
|
|
3342
|
+
If specified, the request's tolerations.
|
|
3343
|
+
|
|
3344
|
+
Tolerations for NoSchedule are required to allocate a device which has a taint with that effect. The same applies to NoExecute.
|
|
3345
|
+
|
|
3346
|
+
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.
|
|
3347
|
+
|
|
3348
|
+
The maximum number of tolerations is 16.
|
|
3349
|
+
|
|
3350
|
+
This is an alpha field and requires enabling the DRADeviceTaints feature gate.
|
|
3351
|
+
"""
|
|
3352
|
+
elif False:
|
|
3353
|
+
DeviceSubRequestPatchArgsDict: TypeAlias = Mapping[str, Any]
|
|
3354
|
+
|
|
3355
|
+
@pulumi.input_type
|
|
3356
|
+
class DeviceSubRequestPatchArgs:
|
|
3357
|
+
def __init__(__self__, *,
|
|
3358
|
+
allocation_mode: Optional[pulumi.Input[builtins.str]] = None,
|
|
3359
|
+
count: Optional[pulumi.Input[builtins.int]] = None,
|
|
3360
|
+
device_class_name: Optional[pulumi.Input[builtins.str]] = None,
|
|
3361
|
+
name: Optional[pulumi.Input[builtins.str]] = None,
|
|
3362
|
+
selectors: Optional[pulumi.Input[Sequence[pulumi.Input['DeviceSelectorPatchArgs']]]] = None,
|
|
3363
|
+
tolerations: Optional[pulumi.Input[Sequence[pulumi.Input['DeviceTolerationPatchArgs']]]] = None):
|
|
3364
|
+
"""
|
|
3365
|
+
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.
|
|
3366
|
+
|
|
3367
|
+
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.
|
|
3368
|
+
:param pulumi.Input[builtins.str] allocation_mode: AllocationMode and its related fields define how devices are allocated to satisfy this request. Supported values are:
|
|
3369
|
+
|
|
3370
|
+
- ExactCount: This request is for a specific number of devices.
|
|
3371
|
+
This is the default. The exact number is provided in the
|
|
3372
|
+
count field.
|
|
3373
|
+
|
|
3374
|
+
- All: This request is for all of the matching devices in a pool.
|
|
3375
|
+
Allocation will fail if some devices are already allocated,
|
|
3376
|
+
unless adminAccess is requested.
|
|
3377
|
+
|
|
3378
|
+
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.
|
|
3379
|
+
|
|
3380
|
+
More modes may get added in the future. Clients must refuse to handle requests with unknown modes.
|
|
3381
|
+
: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.
|
|
3382
|
+
: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.
|
|
3383
|
+
|
|
3384
|
+
A class is required. Which classes are available depends on the cluster.
|
|
3385
|
+
|
|
3386
|
+
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.
|
|
3387
|
+
: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>.
|
|
3388
|
+
|
|
3389
|
+
Must be a DNS label.
|
|
3390
|
+
: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.
|
|
3391
|
+
:param pulumi.Input[Sequence[pulumi.Input['DeviceTolerationPatchArgs']]] tolerations: If specified, the request's tolerations.
|
|
3392
|
+
|
|
3393
|
+
Tolerations for NoSchedule are required to allocate a device which has a taint with that effect. The same applies to NoExecute.
|
|
3394
|
+
|
|
3395
|
+
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.
|
|
3396
|
+
|
|
3397
|
+
The maximum number of tolerations is 16.
|
|
3398
|
+
|
|
3399
|
+
This is an alpha field and requires enabling the DRADeviceTaints feature gate.
|
|
3400
|
+
"""
|
|
3401
|
+
if allocation_mode is not None:
|
|
3402
|
+
pulumi.set(__self__, "allocation_mode", allocation_mode)
|
|
3403
|
+
if count is not None:
|
|
3404
|
+
pulumi.set(__self__, "count", count)
|
|
3405
|
+
if device_class_name is not None:
|
|
3406
|
+
pulumi.set(__self__, "device_class_name", device_class_name)
|
|
3407
|
+
if name is not None:
|
|
3408
|
+
pulumi.set(__self__, "name", name)
|
|
3409
|
+
if selectors is not None:
|
|
3410
|
+
pulumi.set(__self__, "selectors", selectors)
|
|
3411
|
+
if tolerations is not None:
|
|
3412
|
+
pulumi.set(__self__, "tolerations", tolerations)
|
|
3413
|
+
|
|
3414
|
+
@property
|
|
3415
|
+
@pulumi.getter(name="allocationMode")
|
|
3416
|
+
def allocation_mode(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
3417
|
+
"""
|
|
3418
|
+
AllocationMode and its related fields define how devices are allocated to satisfy this request. Supported values are:
|
|
3419
|
+
|
|
3420
|
+
- ExactCount: This request is for a specific number of devices.
|
|
3421
|
+
This is the default. The exact number is provided in the
|
|
3422
|
+
count field.
|
|
3423
|
+
|
|
3424
|
+
- All: This request is for all of the matching devices in a pool.
|
|
3425
|
+
Allocation will fail if some devices are already allocated,
|
|
3426
|
+
unless adminAccess is requested.
|
|
3427
|
+
|
|
3428
|
+
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.
|
|
3429
|
+
|
|
3430
|
+
More modes may get added in the future. Clients must refuse to handle requests with unknown modes.
|
|
3431
|
+
"""
|
|
3432
|
+
return pulumi.get(self, "allocation_mode")
|
|
3433
|
+
|
|
3434
|
+
@allocation_mode.setter
|
|
3435
|
+
def allocation_mode(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
3436
|
+
pulumi.set(self, "allocation_mode", value)
|
|
3437
|
+
|
|
3438
|
+
@property
|
|
3439
|
+
@pulumi.getter
|
|
3440
|
+
def count(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
3441
|
+
"""
|
|
3442
|
+
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.
|
|
3443
|
+
"""
|
|
3444
|
+
return pulumi.get(self, "count")
|
|
3445
|
+
|
|
3446
|
+
@count.setter
|
|
3447
|
+
def count(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
3448
|
+
pulumi.set(self, "count", value)
|
|
3449
|
+
|
|
3450
|
+
@property
|
|
3451
|
+
@pulumi.getter(name="deviceClassName")
|
|
3452
|
+
def device_class_name(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
3453
|
+
"""
|
|
3454
|
+
DeviceClassName references a specific DeviceClass, which can define additional configuration and selectors to be inherited by this subrequest.
|
|
3455
|
+
|
|
3456
|
+
A class is required. Which classes are available depends on the cluster.
|
|
3457
|
+
|
|
3458
|
+
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.
|
|
3459
|
+
"""
|
|
3460
|
+
return pulumi.get(self, "device_class_name")
|
|
3461
|
+
|
|
3462
|
+
@device_class_name.setter
|
|
3463
|
+
def device_class_name(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
3464
|
+
pulumi.set(self, "device_class_name", value)
|
|
3465
|
+
|
|
3466
|
+
@property
|
|
3467
|
+
@pulumi.getter
|
|
3468
|
+
def name(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
3469
|
+
"""
|
|
3470
|
+
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>.
|
|
3471
|
+
|
|
3472
|
+
Must be a DNS label.
|
|
3473
|
+
"""
|
|
3474
|
+
return pulumi.get(self, "name")
|
|
3475
|
+
|
|
3476
|
+
@name.setter
|
|
3477
|
+
def name(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
3478
|
+
pulumi.set(self, "name", value)
|
|
3479
|
+
|
|
3480
|
+
@property
|
|
3481
|
+
@pulumi.getter
|
|
3482
|
+
def selectors(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DeviceSelectorPatchArgs']]]]:
|
|
3483
|
+
"""
|
|
3484
|
+
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.
|
|
3485
|
+
"""
|
|
3486
|
+
return pulumi.get(self, "selectors")
|
|
3487
|
+
|
|
3488
|
+
@selectors.setter
|
|
3489
|
+
def selectors(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DeviceSelectorPatchArgs']]]]):
|
|
3490
|
+
pulumi.set(self, "selectors", value)
|
|
3491
|
+
|
|
3492
|
+
@property
|
|
3493
|
+
@pulumi.getter
|
|
3494
|
+
def tolerations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DeviceTolerationPatchArgs']]]]:
|
|
3495
|
+
"""
|
|
3496
|
+
If specified, the request's tolerations.
|
|
3497
|
+
|
|
3498
|
+
Tolerations for NoSchedule are required to allocate a device which has a taint with that effect. The same applies to NoExecute.
|
|
3499
|
+
|
|
3500
|
+
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.
|
|
3501
|
+
|
|
3502
|
+
The maximum number of tolerations is 16.
|
|
3503
|
+
|
|
3504
|
+
This is an alpha field and requires enabling the DRADeviceTaints feature gate.
|
|
3505
|
+
"""
|
|
3506
|
+
return pulumi.get(self, "tolerations")
|
|
3507
|
+
|
|
3508
|
+
@tolerations.setter
|
|
3509
|
+
def tolerations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DeviceTolerationPatchArgs']]]]):
|
|
3510
|
+
pulumi.set(self, "tolerations", value)
|
|
3511
|
+
|
|
3512
|
+
|
|
3513
|
+
if not MYPY:
|
|
3514
|
+
class DeviceSubRequestArgsDict(TypedDict):
|
|
3515
|
+
"""
|
|
3516
|
+
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.
|
|
3517
|
+
|
|
3518
|
+
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.
|
|
3519
|
+
"""
|
|
3520
|
+
device_class_name: pulumi.Input[builtins.str]
|
|
3521
|
+
"""
|
|
3522
|
+
DeviceClassName references a specific DeviceClass, which can define additional configuration and selectors to be inherited by this subrequest.
|
|
3523
|
+
|
|
3524
|
+
A class is required. Which classes are available depends on the cluster.
|
|
3525
|
+
|
|
3526
|
+
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.
|
|
3527
|
+
"""
|
|
3528
|
+
name: pulumi.Input[builtins.str]
|
|
3529
|
+
"""
|
|
3530
|
+
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>.
|
|
3531
|
+
|
|
3532
|
+
Must be a DNS label.
|
|
3533
|
+
"""
|
|
3534
|
+
allocation_mode: NotRequired[pulumi.Input[builtins.str]]
|
|
3535
|
+
"""
|
|
3536
|
+
AllocationMode and its related fields define how devices are allocated to satisfy this request. Supported values are:
|
|
3537
|
+
|
|
3538
|
+
- ExactCount: This request is for a specific number of devices.
|
|
3539
|
+
This is the default. The exact number is provided in the
|
|
3540
|
+
count field.
|
|
3541
|
+
|
|
3542
|
+
- All: This request is for all of the matching devices in a pool.
|
|
3543
|
+
Allocation will fail if some devices are already allocated,
|
|
3544
|
+
unless adminAccess is requested.
|
|
3545
|
+
|
|
3546
|
+
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.
|
|
3547
|
+
|
|
3548
|
+
More modes may get added in the future. Clients must refuse to handle requests with unknown modes.
|
|
3549
|
+
"""
|
|
3550
|
+
count: NotRequired[pulumi.Input[builtins.int]]
|
|
3551
|
+
"""
|
|
3552
|
+
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.
|
|
3553
|
+
"""
|
|
3554
|
+
selectors: NotRequired[pulumi.Input[Sequence[pulumi.Input['DeviceSelectorArgsDict']]]]
|
|
3555
|
+
"""
|
|
3556
|
+
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.
|
|
3557
|
+
"""
|
|
3558
|
+
tolerations: NotRequired[pulumi.Input[Sequence[pulumi.Input['DeviceTolerationArgsDict']]]]
|
|
3559
|
+
"""
|
|
3560
|
+
If specified, the request's tolerations.
|
|
3561
|
+
|
|
3562
|
+
Tolerations for NoSchedule are required to allocate a device which has a taint with that effect. The same applies to NoExecute.
|
|
3563
|
+
|
|
3564
|
+
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.
|
|
3565
|
+
|
|
3566
|
+
The maximum number of tolerations is 16.
|
|
3567
|
+
|
|
3568
|
+
This is an alpha field and requires enabling the DRADeviceTaints feature gate.
|
|
3569
|
+
"""
|
|
3570
|
+
elif False:
|
|
3571
|
+
DeviceSubRequestArgsDict: TypeAlias = Mapping[str, Any]
|
|
3572
|
+
|
|
3573
|
+
@pulumi.input_type
|
|
3574
|
+
class DeviceSubRequestArgs:
|
|
3575
|
+
def __init__(__self__, *,
|
|
3576
|
+
device_class_name: pulumi.Input[builtins.str],
|
|
3577
|
+
name: pulumi.Input[builtins.str],
|
|
3578
|
+
allocation_mode: Optional[pulumi.Input[builtins.str]] = None,
|
|
3579
|
+
count: Optional[pulumi.Input[builtins.int]] = None,
|
|
3580
|
+
selectors: Optional[pulumi.Input[Sequence[pulumi.Input['DeviceSelectorArgs']]]] = None,
|
|
3581
|
+
tolerations: Optional[pulumi.Input[Sequence[pulumi.Input['DeviceTolerationArgs']]]] = None):
|
|
3582
|
+
"""
|
|
3583
|
+
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.
|
|
3584
|
+
|
|
3585
|
+
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.
|
|
3586
|
+
: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.
|
|
3587
|
+
|
|
3588
|
+
A class is required. Which classes are available depends on the cluster.
|
|
3589
|
+
|
|
3590
|
+
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.
|
|
3591
|
+
: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>.
|
|
3592
|
+
|
|
3593
|
+
Must be a DNS label.
|
|
3594
|
+
:param pulumi.Input[builtins.str] allocation_mode: AllocationMode and its related fields define how devices are allocated to satisfy this request. Supported values are:
|
|
3595
|
+
|
|
3596
|
+
- ExactCount: This request is for a specific number of devices.
|
|
3597
|
+
This is the default. The exact number is provided in the
|
|
3598
|
+
count field.
|
|
3599
|
+
|
|
3600
|
+
- All: This request is for all of the matching devices in a pool.
|
|
3601
|
+
Allocation will fail if some devices are already allocated,
|
|
3602
|
+
unless adminAccess is requested.
|
|
3603
|
+
|
|
3604
|
+
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.
|
|
3605
|
+
|
|
3606
|
+
More modes may get added in the future. Clients must refuse to handle requests with unknown modes.
|
|
3607
|
+
: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.
|
|
3608
|
+
: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.
|
|
3609
|
+
:param pulumi.Input[Sequence[pulumi.Input['DeviceTolerationArgs']]] tolerations: If specified, the request's tolerations.
|
|
3610
|
+
|
|
3611
|
+
Tolerations for NoSchedule are required to allocate a device which has a taint with that effect. The same applies to NoExecute.
|
|
3612
|
+
|
|
3613
|
+
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.
|
|
3614
|
+
|
|
3615
|
+
The maximum number of tolerations is 16.
|
|
3616
|
+
|
|
3617
|
+
This is an alpha field and requires enabling the DRADeviceTaints feature gate.
|
|
3618
|
+
"""
|
|
3619
|
+
pulumi.set(__self__, "device_class_name", device_class_name)
|
|
3620
|
+
pulumi.set(__self__, "name", name)
|
|
3621
|
+
if allocation_mode is not None:
|
|
3622
|
+
pulumi.set(__self__, "allocation_mode", allocation_mode)
|
|
3623
|
+
if count is not None:
|
|
3624
|
+
pulumi.set(__self__, "count", count)
|
|
3625
|
+
if selectors is not None:
|
|
3626
|
+
pulumi.set(__self__, "selectors", selectors)
|
|
3627
|
+
if tolerations is not None:
|
|
3628
|
+
pulumi.set(__self__, "tolerations", tolerations)
|
|
3629
|
+
|
|
3630
|
+
@property
|
|
3631
|
+
@pulumi.getter(name="deviceClassName")
|
|
3632
|
+
def device_class_name(self) -> pulumi.Input[builtins.str]:
|
|
3633
|
+
"""
|
|
3634
|
+
DeviceClassName references a specific DeviceClass, which can define additional configuration and selectors to be inherited by this subrequest.
|
|
3635
|
+
|
|
3636
|
+
A class is required. Which classes are available depends on the cluster.
|
|
3637
|
+
|
|
3638
|
+
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.
|
|
3639
|
+
"""
|
|
3640
|
+
return pulumi.get(self, "device_class_name")
|
|
3641
|
+
|
|
3642
|
+
@device_class_name.setter
|
|
3643
|
+
def device_class_name(self, value: pulumi.Input[builtins.str]):
|
|
3644
|
+
pulumi.set(self, "device_class_name", value)
|
|
3645
|
+
|
|
3646
|
+
@property
|
|
3647
|
+
@pulumi.getter
|
|
3648
|
+
def name(self) -> pulumi.Input[builtins.str]:
|
|
3649
|
+
"""
|
|
3650
|
+
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>.
|
|
3651
|
+
|
|
3652
|
+
Must be a DNS label.
|
|
3653
|
+
"""
|
|
3654
|
+
return pulumi.get(self, "name")
|
|
3655
|
+
|
|
3656
|
+
@name.setter
|
|
3657
|
+
def name(self, value: pulumi.Input[builtins.str]):
|
|
3658
|
+
pulumi.set(self, "name", value)
|
|
3659
|
+
|
|
3660
|
+
@property
|
|
3661
|
+
@pulumi.getter(name="allocationMode")
|
|
3662
|
+
def allocation_mode(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
3663
|
+
"""
|
|
3664
|
+
AllocationMode and its related fields define how devices are allocated to satisfy this request. Supported values are:
|
|
3665
|
+
|
|
3666
|
+
- ExactCount: This request is for a specific number of devices.
|
|
3667
|
+
This is the default. The exact number is provided in the
|
|
3668
|
+
count field.
|
|
3669
|
+
|
|
3670
|
+
- All: This request is for all of the matching devices in a pool.
|
|
3671
|
+
Allocation will fail if some devices are already allocated,
|
|
3672
|
+
unless adminAccess is requested.
|
|
3673
|
+
|
|
3674
|
+
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.
|
|
3675
|
+
|
|
3676
|
+
More modes may get added in the future. Clients must refuse to handle requests with unknown modes.
|
|
3677
|
+
"""
|
|
3678
|
+
return pulumi.get(self, "allocation_mode")
|
|
3679
|
+
|
|
3680
|
+
@allocation_mode.setter
|
|
3681
|
+
def allocation_mode(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
3682
|
+
pulumi.set(self, "allocation_mode", value)
|
|
3683
|
+
|
|
3684
|
+
@property
|
|
3685
|
+
@pulumi.getter
|
|
3686
|
+
def count(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
3687
|
+
"""
|
|
3688
|
+
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.
|
|
3689
|
+
"""
|
|
3690
|
+
return pulumi.get(self, "count")
|
|
3691
|
+
|
|
3692
|
+
@count.setter
|
|
3693
|
+
def count(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
3694
|
+
pulumi.set(self, "count", value)
|
|
3695
|
+
|
|
3696
|
+
@property
|
|
3697
|
+
@pulumi.getter
|
|
3698
|
+
def selectors(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DeviceSelectorArgs']]]]:
|
|
3699
|
+
"""
|
|
3700
|
+
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.
|
|
3701
|
+
"""
|
|
3702
|
+
return pulumi.get(self, "selectors")
|
|
3703
|
+
|
|
3704
|
+
@selectors.setter
|
|
3705
|
+
def selectors(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DeviceSelectorArgs']]]]):
|
|
3706
|
+
pulumi.set(self, "selectors", value)
|
|
3707
|
+
|
|
3708
|
+
@property
|
|
3709
|
+
@pulumi.getter
|
|
3710
|
+
def tolerations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DeviceTolerationArgs']]]]:
|
|
3711
|
+
"""
|
|
3712
|
+
If specified, the request's tolerations.
|
|
3713
|
+
|
|
3714
|
+
Tolerations for NoSchedule are required to allocate a device which has a taint with that effect. The same applies to NoExecute.
|
|
3715
|
+
|
|
3716
|
+
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.
|
|
3717
|
+
|
|
3718
|
+
The maximum number of tolerations is 16.
|
|
3719
|
+
|
|
3720
|
+
This is an alpha field and requires enabling the DRADeviceTaints feature gate.
|
|
3721
|
+
"""
|
|
3722
|
+
return pulumi.get(self, "tolerations")
|
|
3723
|
+
|
|
3724
|
+
@tolerations.setter
|
|
3725
|
+
def tolerations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DeviceTolerationArgs']]]]):
|
|
3726
|
+
pulumi.set(self, "tolerations", value)
|
|
3727
|
+
|
|
3728
|
+
|
|
3729
|
+
if not MYPY:
|
|
3730
|
+
class DeviceTaintPatchArgsDict(TypedDict):
|
|
3731
|
+
"""
|
|
3732
|
+
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.
|
|
3733
|
+
"""
|
|
3734
|
+
effect: NotRequired[pulumi.Input[builtins.str]]
|
|
3735
|
+
"""
|
|
3736
|
+
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.
|
|
3737
|
+
"""
|
|
3738
|
+
key: NotRequired[pulumi.Input[builtins.str]]
|
|
3739
|
+
"""
|
|
3740
|
+
The taint key to be applied to a device. Must be a label name.
|
|
3741
|
+
"""
|
|
3742
|
+
time_added: NotRequired[pulumi.Input[builtins.str]]
|
|
3743
|
+
"""
|
|
3744
|
+
TimeAdded represents the time at which the taint was added. Added automatically during create or update if not set.
|
|
3745
|
+
"""
|
|
3746
|
+
value: NotRequired[pulumi.Input[builtins.str]]
|
|
3747
|
+
"""
|
|
3748
|
+
The taint value corresponding to the taint key. Must be a label value.
|
|
3749
|
+
"""
|
|
3750
|
+
elif False:
|
|
3751
|
+
DeviceTaintPatchArgsDict: TypeAlias = Mapping[str, Any]
|
|
3752
|
+
|
|
3753
|
+
@pulumi.input_type
|
|
3754
|
+
class DeviceTaintPatchArgs:
|
|
3755
|
+
def __init__(__self__, *,
|
|
3756
|
+
effect: Optional[pulumi.Input[builtins.str]] = None,
|
|
3757
|
+
key: Optional[pulumi.Input[builtins.str]] = None,
|
|
3758
|
+
time_added: Optional[pulumi.Input[builtins.str]] = None,
|
|
3759
|
+
value: Optional[pulumi.Input[builtins.str]] = None):
|
|
3760
|
+
"""
|
|
3761
|
+
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.
|
|
3762
|
+
: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.
|
|
3763
|
+
:param pulumi.Input[builtins.str] key: The taint key to be applied to a device. Must be a label name.
|
|
3764
|
+
: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.
|
|
3765
|
+
:param pulumi.Input[builtins.str] value: The taint value corresponding to the taint key. Must be a label value.
|
|
3766
|
+
"""
|
|
3767
|
+
if effect is not None:
|
|
3768
|
+
pulumi.set(__self__, "effect", effect)
|
|
3769
|
+
if key is not None:
|
|
3770
|
+
pulumi.set(__self__, "key", key)
|
|
3771
|
+
if time_added is not None:
|
|
3772
|
+
pulumi.set(__self__, "time_added", time_added)
|
|
3773
|
+
if value is not None:
|
|
3774
|
+
pulumi.set(__self__, "value", value)
|
|
3775
|
+
|
|
3776
|
+
@property
|
|
3777
|
+
@pulumi.getter
|
|
3778
|
+
def effect(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
3779
|
+
"""
|
|
3780
|
+
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.
|
|
3781
|
+
"""
|
|
3782
|
+
return pulumi.get(self, "effect")
|
|
3783
|
+
|
|
3784
|
+
@effect.setter
|
|
3785
|
+
def effect(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
3786
|
+
pulumi.set(self, "effect", value)
|
|
3787
|
+
|
|
3788
|
+
@property
|
|
3789
|
+
@pulumi.getter
|
|
3790
|
+
def key(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
3791
|
+
"""
|
|
3792
|
+
The taint key to be applied to a device. Must be a label name.
|
|
3793
|
+
"""
|
|
3794
|
+
return pulumi.get(self, "key")
|
|
3795
|
+
|
|
3796
|
+
@key.setter
|
|
3797
|
+
def key(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
3798
|
+
pulumi.set(self, "key", value)
|
|
3799
|
+
|
|
3800
|
+
@property
|
|
3801
|
+
@pulumi.getter(name="timeAdded")
|
|
3802
|
+
def time_added(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
3803
|
+
"""
|
|
3804
|
+
TimeAdded represents the time at which the taint was added. Added automatically during create or update if not set.
|
|
3805
|
+
"""
|
|
3806
|
+
return pulumi.get(self, "time_added")
|
|
3807
|
+
|
|
3808
|
+
@time_added.setter
|
|
3809
|
+
def time_added(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
3810
|
+
pulumi.set(self, "time_added", value)
|
|
3811
|
+
|
|
3812
|
+
@property
|
|
3813
|
+
@pulumi.getter
|
|
3814
|
+
def value(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
3815
|
+
"""
|
|
3816
|
+
The taint value corresponding to the taint key. Must be a label value.
|
|
3817
|
+
"""
|
|
3818
|
+
return pulumi.get(self, "value")
|
|
3819
|
+
|
|
3820
|
+
@value.setter
|
|
3821
|
+
def value(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
3822
|
+
pulumi.set(self, "value", value)
|
|
3823
|
+
|
|
3824
|
+
|
|
3825
|
+
if not MYPY:
|
|
3826
|
+
class DeviceTaintRuleSpecPatchArgsDict(TypedDict):
|
|
3827
|
+
"""
|
|
3828
|
+
DeviceTaintRuleSpec specifies the selector and one taint.
|
|
3829
|
+
"""
|
|
3830
|
+
device_selector: NotRequired[pulumi.Input['DeviceTaintSelectorPatchArgsDict']]
|
|
3831
|
+
"""
|
|
3832
|
+
DeviceSelector defines which device(s) the taint is applied to. All selector criteria must be satified for a device to match. The empty selector matches all devices. Without a selector, no devices are matches.
|
|
3833
|
+
"""
|
|
3834
|
+
taint: NotRequired[pulumi.Input['DeviceTaintPatchArgsDict']]
|
|
3835
|
+
"""
|
|
3836
|
+
The taint that gets applied to matching devices.
|
|
3837
|
+
"""
|
|
3838
|
+
elif False:
|
|
3839
|
+
DeviceTaintRuleSpecPatchArgsDict: TypeAlias = Mapping[str, Any]
|
|
3840
|
+
|
|
3841
|
+
@pulumi.input_type
|
|
3842
|
+
class DeviceTaintRuleSpecPatchArgs:
|
|
3843
|
+
def __init__(__self__, *,
|
|
3844
|
+
device_selector: Optional[pulumi.Input['DeviceTaintSelectorPatchArgs']] = None,
|
|
3845
|
+
taint: Optional[pulumi.Input['DeviceTaintPatchArgs']] = None):
|
|
3846
|
+
"""
|
|
3847
|
+
DeviceTaintRuleSpec specifies the selector and one taint.
|
|
3848
|
+
:param pulumi.Input['DeviceTaintSelectorPatchArgs'] device_selector: DeviceSelector defines which device(s) the taint is applied to. All selector criteria must be satified for a device to match. The empty selector matches all devices. Without a selector, no devices are matches.
|
|
3849
|
+
:param pulumi.Input['DeviceTaintPatchArgs'] taint: The taint that gets applied to matching devices.
|
|
3850
|
+
"""
|
|
3851
|
+
if device_selector is not None:
|
|
3852
|
+
pulumi.set(__self__, "device_selector", device_selector)
|
|
3853
|
+
if taint is not None:
|
|
3854
|
+
pulumi.set(__self__, "taint", taint)
|
|
3855
|
+
|
|
3856
|
+
@property
|
|
3857
|
+
@pulumi.getter(name="deviceSelector")
|
|
3858
|
+
def device_selector(self) -> Optional[pulumi.Input['DeviceTaintSelectorPatchArgs']]:
|
|
3859
|
+
"""
|
|
3860
|
+
DeviceSelector defines which device(s) the taint is applied to. All selector criteria must be satified for a device to match. The empty selector matches all devices. Without a selector, no devices are matches.
|
|
3861
|
+
"""
|
|
3862
|
+
return pulumi.get(self, "device_selector")
|
|
3863
|
+
|
|
3864
|
+
@device_selector.setter
|
|
3865
|
+
def device_selector(self, value: Optional[pulumi.Input['DeviceTaintSelectorPatchArgs']]):
|
|
3866
|
+
pulumi.set(self, "device_selector", value)
|
|
3867
|
+
|
|
3868
|
+
@property
|
|
3869
|
+
@pulumi.getter
|
|
3870
|
+
def taint(self) -> Optional[pulumi.Input['DeviceTaintPatchArgs']]:
|
|
3871
|
+
"""
|
|
3872
|
+
The taint that gets applied to matching devices.
|
|
3873
|
+
"""
|
|
3874
|
+
return pulumi.get(self, "taint")
|
|
3875
|
+
|
|
3876
|
+
@taint.setter
|
|
3877
|
+
def taint(self, value: Optional[pulumi.Input['DeviceTaintPatchArgs']]):
|
|
3878
|
+
pulumi.set(self, "taint", value)
|
|
3879
|
+
|
|
3880
|
+
|
|
3881
|
+
if not MYPY:
|
|
3882
|
+
class DeviceTaintRuleSpecArgsDict(TypedDict):
|
|
3883
|
+
"""
|
|
3884
|
+
DeviceTaintRuleSpec specifies the selector and one taint.
|
|
3885
|
+
"""
|
|
3886
|
+
taint: pulumi.Input['DeviceTaintArgsDict']
|
|
3887
|
+
"""
|
|
3888
|
+
The taint that gets applied to matching devices.
|
|
3889
|
+
"""
|
|
3890
|
+
device_selector: NotRequired[pulumi.Input['DeviceTaintSelectorArgsDict']]
|
|
3891
|
+
"""
|
|
3892
|
+
DeviceSelector defines which device(s) the taint is applied to. All selector criteria must be satified for a device to match. The empty selector matches all devices. Without a selector, no devices are matches.
|
|
3893
|
+
"""
|
|
3894
|
+
elif False:
|
|
3895
|
+
DeviceTaintRuleSpecArgsDict: TypeAlias = Mapping[str, Any]
|
|
3896
|
+
|
|
3897
|
+
@pulumi.input_type
|
|
3898
|
+
class DeviceTaintRuleSpecArgs:
|
|
3899
|
+
def __init__(__self__, *,
|
|
3900
|
+
taint: pulumi.Input['DeviceTaintArgs'],
|
|
3901
|
+
device_selector: Optional[pulumi.Input['DeviceTaintSelectorArgs']] = None):
|
|
3902
|
+
"""
|
|
3903
|
+
DeviceTaintRuleSpec specifies the selector and one taint.
|
|
3904
|
+
:param pulumi.Input['DeviceTaintArgs'] taint: The taint that gets applied to matching devices.
|
|
3905
|
+
:param pulumi.Input['DeviceTaintSelectorArgs'] device_selector: DeviceSelector defines which device(s) the taint is applied to. All selector criteria must be satified for a device to match. The empty selector matches all devices. Without a selector, no devices are matches.
|
|
3906
|
+
"""
|
|
3907
|
+
pulumi.set(__self__, "taint", taint)
|
|
3908
|
+
if device_selector is not None:
|
|
3909
|
+
pulumi.set(__self__, "device_selector", device_selector)
|
|
3910
|
+
|
|
3911
|
+
@property
|
|
3912
|
+
@pulumi.getter
|
|
3913
|
+
def taint(self) -> pulumi.Input['DeviceTaintArgs']:
|
|
3914
|
+
"""
|
|
3915
|
+
The taint that gets applied to matching devices.
|
|
3916
|
+
"""
|
|
3917
|
+
return pulumi.get(self, "taint")
|
|
3918
|
+
|
|
3919
|
+
@taint.setter
|
|
3920
|
+
def taint(self, value: pulumi.Input['DeviceTaintArgs']):
|
|
3921
|
+
pulumi.set(self, "taint", value)
|
|
3922
|
+
|
|
3923
|
+
@property
|
|
3924
|
+
@pulumi.getter(name="deviceSelector")
|
|
3925
|
+
def device_selector(self) -> Optional[pulumi.Input['DeviceTaintSelectorArgs']]:
|
|
3926
|
+
"""
|
|
3927
|
+
DeviceSelector defines which device(s) the taint is applied to. All selector criteria must be satified for a device to match. The empty selector matches all devices. Without a selector, no devices are matches.
|
|
3928
|
+
"""
|
|
3929
|
+
return pulumi.get(self, "device_selector")
|
|
3930
|
+
|
|
3931
|
+
@device_selector.setter
|
|
3932
|
+
def device_selector(self, value: Optional[pulumi.Input['DeviceTaintSelectorArgs']]):
|
|
3933
|
+
pulumi.set(self, "device_selector", value)
|
|
3934
|
+
|
|
3935
|
+
|
|
3936
|
+
if not MYPY:
|
|
3937
|
+
class DeviceTaintRuleArgsDict(TypedDict):
|
|
3938
|
+
"""
|
|
3939
|
+
DeviceTaintRule adds one taint to all devices which match the selector. This has the same effect as if the taint was specified directly in the ResourceSlice by the DRA driver.
|
|
3940
|
+
"""
|
|
3941
|
+
spec: pulumi.Input['DeviceTaintRuleSpecArgsDict']
|
|
3942
|
+
"""
|
|
3943
|
+
Spec specifies the selector and one taint.
|
|
3944
|
+
|
|
3945
|
+
Changing the spec automatically increments the metadata.generation number.
|
|
3946
|
+
"""
|
|
3947
|
+
api_version: NotRequired[pulumi.Input[builtins.str]]
|
|
3948
|
+
"""
|
|
3949
|
+
APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources
|
|
3950
|
+
"""
|
|
3951
|
+
kind: NotRequired[pulumi.Input[builtins.str]]
|
|
3952
|
+
"""
|
|
3953
|
+
Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
|
|
3954
|
+
"""
|
|
3955
|
+
metadata: NotRequired[pulumi.Input['_meta.v1.ObjectMetaArgsDict']]
|
|
3956
|
+
"""
|
|
3957
|
+
Standard object metadata
|
|
3958
|
+
"""
|
|
3959
|
+
elif False:
|
|
3960
|
+
DeviceTaintRuleArgsDict: TypeAlias = Mapping[str, Any]
|
|
3961
|
+
|
|
3962
|
+
@pulumi.input_type
|
|
3963
|
+
class DeviceTaintRuleArgs:
|
|
3964
|
+
def __init__(__self__, *,
|
|
3965
|
+
spec: pulumi.Input['DeviceTaintRuleSpecArgs'],
|
|
3966
|
+
api_version: Optional[pulumi.Input[builtins.str]] = None,
|
|
3967
|
+
kind: Optional[pulumi.Input[builtins.str]] = None,
|
|
3968
|
+
metadata: Optional[pulumi.Input['_meta.v1.ObjectMetaArgs']] = None):
|
|
3969
|
+
"""
|
|
3970
|
+
DeviceTaintRule adds one taint to all devices which match the selector. This has the same effect as if the taint was specified directly in the ResourceSlice by the DRA driver.
|
|
3971
|
+
:param pulumi.Input['DeviceTaintRuleSpecArgs'] spec: Spec specifies the selector and one taint.
|
|
3972
|
+
|
|
3973
|
+
Changing the spec automatically increments the metadata.generation number.
|
|
3974
|
+
:param pulumi.Input[builtins.str] api_version: APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources
|
|
3975
|
+
:param pulumi.Input[builtins.str] kind: Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
|
|
3976
|
+
:param pulumi.Input['_meta.v1.ObjectMetaArgs'] metadata: Standard object metadata
|
|
3977
|
+
"""
|
|
3978
|
+
pulumi.set(__self__, "spec", spec)
|
|
3979
|
+
if api_version is not None:
|
|
3980
|
+
pulumi.set(__self__, "api_version", 'resource.k8s.io/v1alpha3')
|
|
3981
|
+
if kind is not None:
|
|
3982
|
+
pulumi.set(__self__, "kind", 'DeviceTaintRule')
|
|
3983
|
+
if metadata is not None:
|
|
3984
|
+
pulumi.set(__self__, "metadata", metadata)
|
|
3985
|
+
|
|
3986
|
+
@property
|
|
3987
|
+
@pulumi.getter
|
|
3988
|
+
def spec(self) -> pulumi.Input['DeviceTaintRuleSpecArgs']:
|
|
3989
|
+
"""
|
|
3990
|
+
Spec specifies the selector and one taint.
|
|
3991
|
+
|
|
3992
|
+
Changing the spec automatically increments the metadata.generation number.
|
|
3993
|
+
"""
|
|
3994
|
+
return pulumi.get(self, "spec")
|
|
3995
|
+
|
|
3996
|
+
@spec.setter
|
|
3997
|
+
def spec(self, value: pulumi.Input['DeviceTaintRuleSpecArgs']):
|
|
3998
|
+
pulumi.set(self, "spec", value)
|
|
3999
|
+
|
|
4000
|
+
@property
|
|
4001
|
+
@pulumi.getter(name="apiVersion")
|
|
4002
|
+
def api_version(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
4003
|
+
"""
|
|
4004
|
+
APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources
|
|
4005
|
+
"""
|
|
4006
|
+
return pulumi.get(self, "api_version")
|
|
4007
|
+
|
|
4008
|
+
@api_version.setter
|
|
4009
|
+
def api_version(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
4010
|
+
pulumi.set(self, "api_version", value)
|
|
4011
|
+
|
|
4012
|
+
@property
|
|
4013
|
+
@pulumi.getter
|
|
4014
|
+
def kind(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
4015
|
+
"""
|
|
4016
|
+
Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
|
|
4017
|
+
"""
|
|
4018
|
+
return pulumi.get(self, "kind")
|
|
4019
|
+
|
|
4020
|
+
@kind.setter
|
|
4021
|
+
def kind(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
4022
|
+
pulumi.set(self, "kind", value)
|
|
4023
|
+
|
|
4024
|
+
@property
|
|
4025
|
+
@pulumi.getter
|
|
4026
|
+
def metadata(self) -> Optional[pulumi.Input['_meta.v1.ObjectMetaArgs']]:
|
|
4027
|
+
"""
|
|
4028
|
+
Standard object metadata
|
|
4029
|
+
"""
|
|
4030
|
+
return pulumi.get(self, "metadata")
|
|
4031
|
+
|
|
4032
|
+
@metadata.setter
|
|
4033
|
+
def metadata(self, value: Optional[pulumi.Input['_meta.v1.ObjectMetaArgs']]):
|
|
4034
|
+
pulumi.set(self, "metadata", value)
|
|
4035
|
+
|
|
4036
|
+
|
|
4037
|
+
if not MYPY:
|
|
4038
|
+
class DeviceTaintSelectorPatchArgsDict(TypedDict):
|
|
4039
|
+
"""
|
|
4040
|
+
DeviceTaintSelector defines which device(s) a DeviceTaintRule applies to. The empty selector matches all devices. Without a selector, no devices are matched.
|
|
4041
|
+
"""
|
|
4042
|
+
device: NotRequired[pulumi.Input[builtins.str]]
|
|
4043
|
+
"""
|
|
4044
|
+
If device is set, only devices with that name are selected. This field corresponds to slice.spec.devices[].name.
|
|
4045
|
+
|
|
4046
|
+
Setting also driver and pool may be required to avoid ambiguity, but is not required.
|
|
4047
|
+
"""
|
|
4048
|
+
device_class_name: NotRequired[pulumi.Input[builtins.str]]
|
|
4049
|
+
"""
|
|
4050
|
+
If DeviceClassName is set, the selectors defined there must be satisfied by a device to be selected. This field corresponds to class.metadata.name.
|
|
4051
|
+
"""
|
|
4052
|
+
driver: NotRequired[pulumi.Input[builtins.str]]
|
|
4053
|
+
"""
|
|
4054
|
+
If driver is set, only devices from that driver are selected. This fields corresponds to slice.spec.driver.
|
|
4055
|
+
"""
|
|
4056
|
+
pool: NotRequired[pulumi.Input[builtins.str]]
|
|
4057
|
+
"""
|
|
4058
|
+
If pool is set, only devices in that pool are selected.
|
|
4059
|
+
|
|
4060
|
+
Also setting the driver name may be useful to avoid ambiguity when different drivers use the same pool name, but this is not required because selecting pools from different drivers may also be useful, for example when drivers with node-local devices use the node name as their pool name.
|
|
4061
|
+
"""
|
|
4062
|
+
selectors: NotRequired[pulumi.Input[Sequence[pulumi.Input['DeviceSelectorPatchArgsDict']]]]
|
|
4063
|
+
"""
|
|
4064
|
+
Selectors contains the same selection criteria as a ResourceClaim. Currently, CEL expressions are supported. All of these selectors must be satisfied.
|
|
4065
|
+
"""
|
|
4066
|
+
elif False:
|
|
4067
|
+
DeviceTaintSelectorPatchArgsDict: TypeAlias = Mapping[str, Any]
|
|
4068
|
+
|
|
4069
|
+
@pulumi.input_type
|
|
4070
|
+
class DeviceTaintSelectorPatchArgs:
|
|
4071
|
+
def __init__(__self__, *,
|
|
4072
|
+
device: Optional[pulumi.Input[builtins.str]] = None,
|
|
4073
|
+
device_class_name: Optional[pulumi.Input[builtins.str]] = None,
|
|
4074
|
+
driver: Optional[pulumi.Input[builtins.str]] = None,
|
|
4075
|
+
pool: Optional[pulumi.Input[builtins.str]] = None,
|
|
4076
|
+
selectors: Optional[pulumi.Input[Sequence[pulumi.Input['DeviceSelectorPatchArgs']]]] = None):
|
|
4077
|
+
"""
|
|
4078
|
+
DeviceTaintSelector defines which device(s) a DeviceTaintRule applies to. The empty selector matches all devices. Without a selector, no devices are matched.
|
|
4079
|
+
:param pulumi.Input[builtins.str] device: If device is set, only devices with that name are selected. This field corresponds to slice.spec.devices[].name.
|
|
4080
|
+
|
|
4081
|
+
Setting also driver and pool may be required to avoid ambiguity, but is not required.
|
|
4082
|
+
:param pulumi.Input[builtins.str] device_class_name: If DeviceClassName is set, the selectors defined there must be satisfied by a device to be selected. This field corresponds to class.metadata.name.
|
|
4083
|
+
:param pulumi.Input[builtins.str] driver: If driver is set, only devices from that driver are selected. This fields corresponds to slice.spec.driver.
|
|
4084
|
+
:param pulumi.Input[builtins.str] pool: If pool is set, only devices in that pool are selected.
|
|
4085
|
+
|
|
4086
|
+
Also setting the driver name may be useful to avoid ambiguity when different drivers use the same pool name, but this is not required because selecting pools from different drivers may also be useful, for example when drivers with node-local devices use the node name as their pool name.
|
|
4087
|
+
:param pulumi.Input[Sequence[pulumi.Input['DeviceSelectorPatchArgs']]] selectors: Selectors contains the same selection criteria as a ResourceClaim. Currently, CEL expressions are supported. All of these selectors must be satisfied.
|
|
4088
|
+
"""
|
|
4089
|
+
if device is not None:
|
|
4090
|
+
pulumi.set(__self__, "device", device)
|
|
4091
|
+
if device_class_name is not None:
|
|
4092
|
+
pulumi.set(__self__, "device_class_name", device_class_name)
|
|
4093
|
+
if driver is not None:
|
|
4094
|
+
pulumi.set(__self__, "driver", driver)
|
|
4095
|
+
if pool is not None:
|
|
4096
|
+
pulumi.set(__self__, "pool", pool)
|
|
4097
|
+
if selectors is not None:
|
|
4098
|
+
pulumi.set(__self__, "selectors", selectors)
|
|
4099
|
+
|
|
4100
|
+
@property
|
|
4101
|
+
@pulumi.getter
|
|
4102
|
+
def device(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
4103
|
+
"""
|
|
4104
|
+
If device is set, only devices with that name are selected. This field corresponds to slice.spec.devices[].name.
|
|
4105
|
+
|
|
4106
|
+
Setting also driver and pool may be required to avoid ambiguity, but is not required.
|
|
4107
|
+
"""
|
|
4108
|
+
return pulumi.get(self, "device")
|
|
4109
|
+
|
|
4110
|
+
@device.setter
|
|
4111
|
+
def device(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
4112
|
+
pulumi.set(self, "device", value)
|
|
4113
|
+
|
|
4114
|
+
@property
|
|
4115
|
+
@pulumi.getter(name="deviceClassName")
|
|
4116
|
+
def device_class_name(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
4117
|
+
"""
|
|
4118
|
+
If DeviceClassName is set, the selectors defined there must be satisfied by a device to be selected. This field corresponds to class.metadata.name.
|
|
4119
|
+
"""
|
|
4120
|
+
return pulumi.get(self, "device_class_name")
|
|
4121
|
+
|
|
4122
|
+
@device_class_name.setter
|
|
4123
|
+
def device_class_name(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
4124
|
+
pulumi.set(self, "device_class_name", value)
|
|
4125
|
+
|
|
4126
|
+
@property
|
|
4127
|
+
@pulumi.getter
|
|
4128
|
+
def driver(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
4129
|
+
"""
|
|
4130
|
+
If driver is set, only devices from that driver are selected. This fields corresponds to slice.spec.driver.
|
|
4131
|
+
"""
|
|
4132
|
+
return pulumi.get(self, "driver")
|
|
4133
|
+
|
|
4134
|
+
@driver.setter
|
|
4135
|
+
def driver(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
4136
|
+
pulumi.set(self, "driver", value)
|
|
4137
|
+
|
|
4138
|
+
@property
|
|
4139
|
+
@pulumi.getter
|
|
4140
|
+
def pool(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
4141
|
+
"""
|
|
4142
|
+
If pool is set, only devices in that pool are selected.
|
|
4143
|
+
|
|
4144
|
+
Also setting the driver name may be useful to avoid ambiguity when different drivers use the same pool name, but this is not required because selecting pools from different drivers may also be useful, for example when drivers with node-local devices use the node name as their pool name.
|
|
4145
|
+
"""
|
|
4146
|
+
return pulumi.get(self, "pool")
|
|
4147
|
+
|
|
4148
|
+
@pool.setter
|
|
4149
|
+
def pool(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
4150
|
+
pulumi.set(self, "pool", value)
|
|
4151
|
+
|
|
4152
|
+
@property
|
|
4153
|
+
@pulumi.getter
|
|
4154
|
+
def selectors(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DeviceSelectorPatchArgs']]]]:
|
|
4155
|
+
"""
|
|
4156
|
+
Selectors contains the same selection criteria as a ResourceClaim. Currently, CEL expressions are supported. All of these selectors must be satisfied.
|
|
4157
|
+
"""
|
|
4158
|
+
return pulumi.get(self, "selectors")
|
|
4159
|
+
|
|
4160
|
+
@selectors.setter
|
|
4161
|
+
def selectors(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DeviceSelectorPatchArgs']]]]):
|
|
4162
|
+
pulumi.set(self, "selectors", value)
|
|
4163
|
+
|
|
4164
|
+
|
|
4165
|
+
if not MYPY:
|
|
4166
|
+
class DeviceTaintSelectorArgsDict(TypedDict):
|
|
4167
|
+
"""
|
|
4168
|
+
DeviceTaintSelector defines which device(s) a DeviceTaintRule applies to. The empty selector matches all devices. Without a selector, no devices are matched.
|
|
4169
|
+
"""
|
|
4170
|
+
device: NotRequired[pulumi.Input[builtins.str]]
|
|
4171
|
+
"""
|
|
4172
|
+
If device is set, only devices with that name are selected. This field corresponds to slice.spec.devices[].name.
|
|
4173
|
+
|
|
4174
|
+
Setting also driver and pool may be required to avoid ambiguity, but is not required.
|
|
4175
|
+
"""
|
|
4176
|
+
device_class_name: NotRequired[pulumi.Input[builtins.str]]
|
|
4177
|
+
"""
|
|
4178
|
+
If DeviceClassName is set, the selectors defined there must be satisfied by a device to be selected. This field corresponds to class.metadata.name.
|
|
4179
|
+
"""
|
|
4180
|
+
driver: NotRequired[pulumi.Input[builtins.str]]
|
|
4181
|
+
"""
|
|
4182
|
+
If driver is set, only devices from that driver are selected. This fields corresponds to slice.spec.driver.
|
|
4183
|
+
"""
|
|
4184
|
+
pool: NotRequired[pulumi.Input[builtins.str]]
|
|
4185
|
+
"""
|
|
4186
|
+
If pool is set, only devices in that pool are selected.
|
|
4187
|
+
|
|
4188
|
+
Also setting the driver name may be useful to avoid ambiguity when different drivers use the same pool name, but this is not required because selecting pools from different drivers may also be useful, for example when drivers with node-local devices use the node name as their pool name.
|
|
4189
|
+
"""
|
|
4190
|
+
selectors: NotRequired[pulumi.Input[Sequence[pulumi.Input['DeviceSelectorArgsDict']]]]
|
|
4191
|
+
"""
|
|
4192
|
+
Selectors contains the same selection criteria as a ResourceClaim. Currently, CEL expressions are supported. All of these selectors must be satisfied.
|
|
4193
|
+
"""
|
|
4194
|
+
elif False:
|
|
4195
|
+
DeviceTaintSelectorArgsDict: TypeAlias = Mapping[str, Any]
|
|
4196
|
+
|
|
4197
|
+
@pulumi.input_type
|
|
4198
|
+
class DeviceTaintSelectorArgs:
|
|
4199
|
+
def __init__(__self__, *,
|
|
4200
|
+
device: Optional[pulumi.Input[builtins.str]] = None,
|
|
4201
|
+
device_class_name: Optional[pulumi.Input[builtins.str]] = None,
|
|
4202
|
+
driver: Optional[pulumi.Input[builtins.str]] = None,
|
|
4203
|
+
pool: Optional[pulumi.Input[builtins.str]] = None,
|
|
4204
|
+
selectors: Optional[pulumi.Input[Sequence[pulumi.Input['DeviceSelectorArgs']]]] = None):
|
|
4205
|
+
"""
|
|
4206
|
+
DeviceTaintSelector defines which device(s) a DeviceTaintRule applies to. The empty selector matches all devices. Without a selector, no devices are matched.
|
|
4207
|
+
:param pulumi.Input[builtins.str] device: If device is set, only devices with that name are selected. This field corresponds to slice.spec.devices[].name.
|
|
4208
|
+
|
|
4209
|
+
Setting also driver and pool may be required to avoid ambiguity, but is not required.
|
|
4210
|
+
:param pulumi.Input[builtins.str] device_class_name: If DeviceClassName is set, the selectors defined there must be satisfied by a device to be selected. This field corresponds to class.metadata.name.
|
|
4211
|
+
:param pulumi.Input[builtins.str] driver: If driver is set, only devices from that driver are selected. This fields corresponds to slice.spec.driver.
|
|
4212
|
+
:param pulumi.Input[builtins.str] pool: If pool is set, only devices in that pool are selected.
|
|
4213
|
+
|
|
4214
|
+
Also setting the driver name may be useful to avoid ambiguity when different drivers use the same pool name, but this is not required because selecting pools from different drivers may also be useful, for example when drivers with node-local devices use the node name as their pool name.
|
|
4215
|
+
:param pulumi.Input[Sequence[pulumi.Input['DeviceSelectorArgs']]] selectors: Selectors contains the same selection criteria as a ResourceClaim. Currently, CEL expressions are supported. All of these selectors must be satisfied.
|
|
2218
4216
|
"""
|
|
2219
|
-
|
|
2220
|
-
|
|
2221
|
-
if
|
|
2222
|
-
pulumi.set(__self__, "
|
|
2223
|
-
if
|
|
2224
|
-
pulumi.set(__self__, "
|
|
2225
|
-
if
|
|
2226
|
-
pulumi.set(__self__, "
|
|
4217
|
+
if device is not None:
|
|
4218
|
+
pulumi.set(__self__, "device", device)
|
|
4219
|
+
if device_class_name is not None:
|
|
4220
|
+
pulumi.set(__self__, "device_class_name", device_class_name)
|
|
4221
|
+
if driver is not None:
|
|
4222
|
+
pulumi.set(__self__, "driver", driver)
|
|
4223
|
+
if pool is not None:
|
|
4224
|
+
pulumi.set(__self__, "pool", pool)
|
|
2227
4225
|
if selectors is not None:
|
|
2228
4226
|
pulumi.set(__self__, "selectors", selectors)
|
|
2229
4227
|
|
|
2230
4228
|
@property
|
|
2231
|
-
@pulumi.getter
|
|
2232
|
-
def
|
|
4229
|
+
@pulumi.getter
|
|
4230
|
+
def device(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
2233
4231
|
"""
|
|
2234
|
-
|
|
4232
|
+
If device is set, only devices with that name are selected. This field corresponds to slice.spec.devices[].name.
|
|
2235
4233
|
|
|
2236
|
-
|
|
4234
|
+
Setting also driver and pool may be required to avoid ambiguity, but is not required.
|
|
4235
|
+
"""
|
|
4236
|
+
return pulumi.get(self, "device")
|
|
2237
4237
|
|
|
2238
|
-
|
|
4238
|
+
@device.setter
|
|
4239
|
+
def device(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
4240
|
+
pulumi.set(self, "device", value)
|
|
4241
|
+
|
|
4242
|
+
@property
|
|
4243
|
+
@pulumi.getter(name="deviceClassName")
|
|
4244
|
+
def device_class_name(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
4245
|
+
"""
|
|
4246
|
+
If DeviceClassName is set, the selectors defined there must be satisfied by a device to be selected. This field corresponds to class.metadata.name.
|
|
2239
4247
|
"""
|
|
2240
4248
|
return pulumi.get(self, "device_class_name")
|
|
2241
4249
|
|
|
2242
4250
|
@device_class_name.setter
|
|
2243
|
-
def device_class_name(self, value: pulumi.Input[builtins.str]):
|
|
4251
|
+
def device_class_name(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
2244
4252
|
pulumi.set(self, "device_class_name", value)
|
|
2245
4253
|
|
|
2246
4254
|
@property
|
|
2247
4255
|
@pulumi.getter
|
|
2248
|
-
def
|
|
4256
|
+
def driver(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
2249
4257
|
"""
|
|
2250
|
-
|
|
2251
|
-
|
|
2252
|
-
Must be a DNS label.
|
|
4258
|
+
If driver is set, only devices from that driver are selected. This fields corresponds to slice.spec.driver.
|
|
2253
4259
|
"""
|
|
2254
|
-
return pulumi.get(self, "
|
|
4260
|
+
return pulumi.get(self, "driver")
|
|
2255
4261
|
|
|
2256
|
-
@
|
|
2257
|
-
def
|
|
2258
|
-
pulumi.set(self, "
|
|
4262
|
+
@driver.setter
|
|
4263
|
+
def driver(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
4264
|
+
pulumi.set(self, "driver", value)
|
|
2259
4265
|
|
|
2260
4266
|
@property
|
|
2261
|
-
@pulumi.getter
|
|
2262
|
-
def
|
|
4267
|
+
@pulumi.getter
|
|
4268
|
+
def pool(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
2263
4269
|
"""
|
|
2264
|
-
|
|
4270
|
+
If pool is set, only devices in that pool are selected.
|
|
2265
4271
|
|
|
2266
|
-
|
|
4272
|
+
Also setting the driver name may be useful to avoid ambiguity when different drivers use the same pool name, but this is not required because selecting pools from different drivers may also be useful, for example when drivers with node-local devices use the node name as their pool name.
|
|
2267
4273
|
"""
|
|
2268
|
-
return pulumi.get(self, "
|
|
4274
|
+
return pulumi.get(self, "pool")
|
|
2269
4275
|
|
|
2270
|
-
@
|
|
2271
|
-
def
|
|
2272
|
-
pulumi.set(self, "
|
|
4276
|
+
@pool.setter
|
|
4277
|
+
def pool(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
4278
|
+
pulumi.set(self, "pool", value)
|
|
2273
4279
|
|
|
2274
4280
|
@property
|
|
2275
|
-
@pulumi.getter
|
|
2276
|
-
def
|
|
4281
|
+
@pulumi.getter
|
|
4282
|
+
def selectors(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DeviceSelectorArgs']]]]:
|
|
2277
4283
|
"""
|
|
2278
|
-
|
|
4284
|
+
Selectors contains the same selection criteria as a ResourceClaim. Currently, CEL expressions are supported. All of these selectors must be satisfied.
|
|
4285
|
+
"""
|
|
4286
|
+
return pulumi.get(self, "selectors")
|
|
2279
4287
|
|
|
2280
|
-
|
|
2281
|
-
|
|
2282
|
-
|
|
4288
|
+
@selectors.setter
|
|
4289
|
+
def selectors(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DeviceSelectorArgs']]]]):
|
|
4290
|
+
pulumi.set(self, "selectors", value)
|
|
2283
4291
|
|
|
2284
|
-
- All: This request is for all of the matching devices in a pool.
|
|
2285
|
-
Allocation will fail if some devices are already allocated,
|
|
2286
|
-
unless adminAccess is requested.
|
|
2287
4292
|
|
|
2288
|
-
|
|
4293
|
+
if not MYPY:
|
|
4294
|
+
class DeviceTaintArgsDict(TypedDict):
|
|
4295
|
+
"""
|
|
4296
|
+
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.
|
|
4297
|
+
"""
|
|
4298
|
+
effect: pulumi.Input[builtins.str]
|
|
4299
|
+
"""
|
|
4300
|
+
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.
|
|
4301
|
+
"""
|
|
4302
|
+
key: pulumi.Input[builtins.str]
|
|
4303
|
+
"""
|
|
4304
|
+
The taint key to be applied to a device. Must be a label name.
|
|
4305
|
+
"""
|
|
4306
|
+
time_added: NotRequired[pulumi.Input[builtins.str]]
|
|
4307
|
+
"""
|
|
4308
|
+
TimeAdded represents the time at which the taint was added. Added automatically during create or update if not set.
|
|
4309
|
+
"""
|
|
4310
|
+
value: NotRequired[pulumi.Input[builtins.str]]
|
|
4311
|
+
"""
|
|
4312
|
+
The taint value corresponding to the taint key. Must be a label value.
|
|
4313
|
+
"""
|
|
4314
|
+
elif False:
|
|
4315
|
+
DeviceTaintArgsDict: TypeAlias = Mapping[str, Any]
|
|
2289
4316
|
|
|
2290
|
-
|
|
4317
|
+
@pulumi.input_type
|
|
4318
|
+
class DeviceTaintArgs:
|
|
4319
|
+
def __init__(__self__, *,
|
|
4320
|
+
effect: pulumi.Input[builtins.str],
|
|
4321
|
+
key: pulumi.Input[builtins.str],
|
|
4322
|
+
time_added: Optional[pulumi.Input[builtins.str]] = None,
|
|
4323
|
+
value: Optional[pulumi.Input[builtins.str]] = None):
|
|
2291
4324
|
"""
|
|
2292
|
-
|
|
4325
|
+
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.
|
|
4326
|
+
: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.
|
|
4327
|
+
:param pulumi.Input[builtins.str] key: The taint key to be applied to a device. Must be a label name.
|
|
4328
|
+
: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.
|
|
4329
|
+
:param pulumi.Input[builtins.str] value: The taint value corresponding to the taint key. Must be a label value.
|
|
4330
|
+
"""
|
|
4331
|
+
pulumi.set(__self__, "effect", effect)
|
|
4332
|
+
pulumi.set(__self__, "key", key)
|
|
4333
|
+
if time_added is not None:
|
|
4334
|
+
pulumi.set(__self__, "time_added", time_added)
|
|
4335
|
+
if value is not None:
|
|
4336
|
+
pulumi.set(__self__, "value", value)
|
|
2293
4337
|
|
|
2294
|
-
@
|
|
2295
|
-
|
|
2296
|
-
|
|
4338
|
+
@property
|
|
4339
|
+
@pulumi.getter
|
|
4340
|
+
def effect(self) -> pulumi.Input[builtins.str]:
|
|
4341
|
+
"""
|
|
4342
|
+
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.
|
|
4343
|
+
"""
|
|
4344
|
+
return pulumi.get(self, "effect")
|
|
4345
|
+
|
|
4346
|
+
@effect.setter
|
|
4347
|
+
def effect(self, value: pulumi.Input[builtins.str]):
|
|
4348
|
+
pulumi.set(self, "effect", value)
|
|
2297
4349
|
|
|
2298
4350
|
@property
|
|
2299
4351
|
@pulumi.getter
|
|
2300
|
-
def
|
|
4352
|
+
def key(self) -> pulumi.Input[builtins.str]:
|
|
2301
4353
|
"""
|
|
2302
|
-
|
|
4354
|
+
The taint key to be applied to a device. Must be a label name.
|
|
2303
4355
|
"""
|
|
2304
|
-
return pulumi.get(self, "
|
|
4356
|
+
return pulumi.get(self, "key")
|
|
2305
4357
|
|
|
2306
|
-
@
|
|
2307
|
-
def
|
|
2308
|
-
pulumi.set(self, "
|
|
4358
|
+
@key.setter
|
|
4359
|
+
def key(self, value: pulumi.Input[builtins.str]):
|
|
4360
|
+
pulumi.set(self, "key", value)
|
|
4361
|
+
|
|
4362
|
+
@property
|
|
4363
|
+
@pulumi.getter(name="timeAdded")
|
|
4364
|
+
def time_added(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
4365
|
+
"""
|
|
4366
|
+
TimeAdded represents the time at which the taint was added. Added automatically during create or update if not set.
|
|
4367
|
+
"""
|
|
4368
|
+
return pulumi.get(self, "time_added")
|
|
4369
|
+
|
|
4370
|
+
@time_added.setter
|
|
4371
|
+
def time_added(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
4372
|
+
pulumi.set(self, "time_added", value)
|
|
2309
4373
|
|
|
2310
4374
|
@property
|
|
2311
4375
|
@pulumi.getter
|
|
2312
|
-
def
|
|
4376
|
+
def value(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
2313
4377
|
"""
|
|
2314
|
-
|
|
4378
|
+
The taint value corresponding to the taint key. Must be a label value.
|
|
2315
4379
|
"""
|
|
2316
|
-
return pulumi.get(self, "
|
|
4380
|
+
return pulumi.get(self, "value")
|
|
2317
4381
|
|
|
2318
|
-
@
|
|
2319
|
-
def
|
|
2320
|
-
pulumi.set(self, "
|
|
4382
|
+
@value.setter
|
|
4383
|
+
def value(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
4384
|
+
pulumi.set(self, "value", value)
|
|
2321
4385
|
|
|
2322
4386
|
|
|
2323
4387
|
if not MYPY:
|
|
2324
|
-
class
|
|
4388
|
+
class DeviceTolerationPatchArgsDict(TypedDict):
|
|
2325
4389
|
"""
|
|
2326
|
-
|
|
4390
|
+
The ResourceClaim this DeviceToleration is attached to tolerates any taint that matches the triple <key,value,effect> using the matching operator <operator>.
|
|
2327
4391
|
"""
|
|
2328
|
-
|
|
4392
|
+
effect: NotRequired[pulumi.Input[builtins.str]]
|
|
2329
4393
|
"""
|
|
2330
|
-
|
|
4394
|
+
Effect indicates the taint effect to match. Empty means match all taint effects. When specified, allowed values are NoSchedule and NoExecute.
|
|
4395
|
+
"""
|
|
4396
|
+
key: NotRequired[pulumi.Input[builtins.str]]
|
|
4397
|
+
"""
|
|
4398
|
+
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.
|
|
4399
|
+
"""
|
|
4400
|
+
operator: NotRequired[pulumi.Input[builtins.str]]
|
|
4401
|
+
"""
|
|
4402
|
+
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.
|
|
4403
|
+
"""
|
|
4404
|
+
toleration_seconds: NotRequired[pulumi.Input[builtins.int]]
|
|
4405
|
+
"""
|
|
4406
|
+
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>.
|
|
4407
|
+
"""
|
|
4408
|
+
value: NotRequired[pulumi.Input[builtins.str]]
|
|
4409
|
+
"""
|
|
4410
|
+
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.
|
|
2331
4411
|
"""
|
|
2332
4412
|
elif False:
|
|
2333
|
-
|
|
4413
|
+
DeviceTolerationPatchArgsDict: TypeAlias = Mapping[str, Any]
|
|
2334
4414
|
|
|
2335
4415
|
@pulumi.input_type
|
|
2336
|
-
class
|
|
4416
|
+
class DeviceTolerationPatchArgs:
|
|
2337
4417
|
def __init__(__self__, *,
|
|
2338
|
-
|
|
4418
|
+
effect: Optional[pulumi.Input[builtins.str]] = None,
|
|
4419
|
+
key: Optional[pulumi.Input[builtins.str]] = None,
|
|
4420
|
+
operator: Optional[pulumi.Input[builtins.str]] = None,
|
|
4421
|
+
toleration_seconds: Optional[pulumi.Input[builtins.int]] = None,
|
|
4422
|
+
value: Optional[pulumi.Input[builtins.str]] = None):
|
|
4423
|
+
"""
|
|
4424
|
+
The ResourceClaim this DeviceToleration is attached to tolerates any taint that matches the triple <key,value,effect> using the matching operator <operator>.
|
|
4425
|
+
: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.
|
|
4426
|
+
: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.
|
|
4427
|
+
: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.
|
|
4428
|
+
: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>.
|
|
4429
|
+
: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.
|
|
4430
|
+
"""
|
|
4431
|
+
if effect is not None:
|
|
4432
|
+
pulumi.set(__self__, "effect", effect)
|
|
4433
|
+
if key is not None:
|
|
4434
|
+
pulumi.set(__self__, "key", key)
|
|
4435
|
+
if operator is not None:
|
|
4436
|
+
pulumi.set(__self__, "operator", operator)
|
|
4437
|
+
if toleration_seconds is not None:
|
|
4438
|
+
pulumi.set(__self__, "toleration_seconds", toleration_seconds)
|
|
4439
|
+
if value is not None:
|
|
4440
|
+
pulumi.set(__self__, "value", value)
|
|
4441
|
+
|
|
4442
|
+
@property
|
|
4443
|
+
@pulumi.getter
|
|
4444
|
+
def effect(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
2339
4445
|
"""
|
|
2340
|
-
|
|
2341
|
-
:param pulumi.Input['CELDeviceSelectorPatchArgs'] cel: CEL contains a CEL expression for selecting a device.
|
|
4446
|
+
Effect indicates the taint effect to match. Empty means match all taint effects. When specified, allowed values are NoSchedule and NoExecute.
|
|
2342
4447
|
"""
|
|
2343
|
-
|
|
2344
|
-
|
|
4448
|
+
return pulumi.get(self, "effect")
|
|
4449
|
+
|
|
4450
|
+
@effect.setter
|
|
4451
|
+
def effect(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
4452
|
+
pulumi.set(self, "effect", value)
|
|
2345
4453
|
|
|
2346
4454
|
@property
|
|
2347
4455
|
@pulumi.getter
|
|
2348
|
-
def
|
|
4456
|
+
def key(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
2349
4457
|
"""
|
|
2350
|
-
|
|
4458
|
+
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.
|
|
2351
4459
|
"""
|
|
2352
|
-
return pulumi.get(self, "
|
|
4460
|
+
return pulumi.get(self, "key")
|
|
2353
4461
|
|
|
2354
|
-
@
|
|
2355
|
-
def
|
|
2356
|
-
pulumi.set(self, "
|
|
4462
|
+
@key.setter
|
|
4463
|
+
def key(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
4464
|
+
pulumi.set(self, "key", value)
|
|
4465
|
+
|
|
4466
|
+
@property
|
|
4467
|
+
@pulumi.getter
|
|
4468
|
+
def operator(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
4469
|
+
"""
|
|
4470
|
+
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.
|
|
4471
|
+
"""
|
|
4472
|
+
return pulumi.get(self, "operator")
|
|
4473
|
+
|
|
4474
|
+
@operator.setter
|
|
4475
|
+
def operator(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
4476
|
+
pulumi.set(self, "operator", value)
|
|
4477
|
+
|
|
4478
|
+
@property
|
|
4479
|
+
@pulumi.getter(name="tolerationSeconds")
|
|
4480
|
+
def toleration_seconds(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
4481
|
+
"""
|
|
4482
|
+
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>.
|
|
4483
|
+
"""
|
|
4484
|
+
return pulumi.get(self, "toleration_seconds")
|
|
4485
|
+
|
|
4486
|
+
@toleration_seconds.setter
|
|
4487
|
+
def toleration_seconds(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
4488
|
+
pulumi.set(self, "toleration_seconds", value)
|
|
4489
|
+
|
|
4490
|
+
@property
|
|
4491
|
+
@pulumi.getter
|
|
4492
|
+
def value(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
4493
|
+
"""
|
|
4494
|
+
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.
|
|
4495
|
+
"""
|
|
4496
|
+
return pulumi.get(self, "value")
|
|
4497
|
+
|
|
4498
|
+
@value.setter
|
|
4499
|
+
def value(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
4500
|
+
pulumi.set(self, "value", value)
|
|
2357
4501
|
|
|
2358
4502
|
|
|
2359
4503
|
if not MYPY:
|
|
2360
|
-
class
|
|
4504
|
+
class DeviceTolerationArgsDict(TypedDict):
|
|
2361
4505
|
"""
|
|
2362
|
-
|
|
4506
|
+
The ResourceClaim this DeviceToleration is attached to tolerates any taint that matches the triple <key,value,effect> using the matching operator <operator>.
|
|
2363
4507
|
"""
|
|
2364
|
-
|
|
4508
|
+
effect: NotRequired[pulumi.Input[builtins.str]]
|
|
2365
4509
|
"""
|
|
2366
|
-
|
|
4510
|
+
Effect indicates the taint effect to match. Empty means match all taint effects. When specified, allowed values are NoSchedule and NoExecute.
|
|
4511
|
+
"""
|
|
4512
|
+
key: NotRequired[pulumi.Input[builtins.str]]
|
|
4513
|
+
"""
|
|
4514
|
+
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.
|
|
4515
|
+
"""
|
|
4516
|
+
operator: NotRequired[pulumi.Input[builtins.str]]
|
|
4517
|
+
"""
|
|
4518
|
+
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.
|
|
4519
|
+
"""
|
|
4520
|
+
toleration_seconds: NotRequired[pulumi.Input[builtins.int]]
|
|
4521
|
+
"""
|
|
4522
|
+
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>.
|
|
4523
|
+
"""
|
|
4524
|
+
value: NotRequired[pulumi.Input[builtins.str]]
|
|
4525
|
+
"""
|
|
4526
|
+
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.
|
|
2367
4527
|
"""
|
|
2368
4528
|
elif False:
|
|
2369
|
-
|
|
4529
|
+
DeviceTolerationArgsDict: TypeAlias = Mapping[str, Any]
|
|
2370
4530
|
|
|
2371
4531
|
@pulumi.input_type
|
|
2372
|
-
class
|
|
4532
|
+
class DeviceTolerationArgs:
|
|
2373
4533
|
def __init__(__self__, *,
|
|
2374
|
-
|
|
4534
|
+
effect: Optional[pulumi.Input[builtins.str]] = None,
|
|
4535
|
+
key: Optional[pulumi.Input[builtins.str]] = None,
|
|
4536
|
+
operator: Optional[pulumi.Input[builtins.str]] = None,
|
|
4537
|
+
toleration_seconds: Optional[pulumi.Input[builtins.int]] = None,
|
|
4538
|
+
value: Optional[pulumi.Input[builtins.str]] = None):
|
|
4539
|
+
"""
|
|
4540
|
+
The ResourceClaim this DeviceToleration is attached to tolerates any taint that matches the triple <key,value,effect> using the matching operator <operator>.
|
|
4541
|
+
: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.
|
|
4542
|
+
: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.
|
|
4543
|
+
: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.
|
|
4544
|
+
: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>.
|
|
4545
|
+
: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.
|
|
4546
|
+
"""
|
|
4547
|
+
if effect is not None:
|
|
4548
|
+
pulumi.set(__self__, "effect", effect)
|
|
4549
|
+
if key is not None:
|
|
4550
|
+
pulumi.set(__self__, "key", key)
|
|
4551
|
+
if operator is not None:
|
|
4552
|
+
pulumi.set(__self__, "operator", operator)
|
|
4553
|
+
if toleration_seconds is not None:
|
|
4554
|
+
pulumi.set(__self__, "toleration_seconds", toleration_seconds)
|
|
4555
|
+
if value is not None:
|
|
4556
|
+
pulumi.set(__self__, "value", value)
|
|
4557
|
+
|
|
4558
|
+
@property
|
|
4559
|
+
@pulumi.getter
|
|
4560
|
+
def effect(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
2375
4561
|
"""
|
|
2376
|
-
|
|
2377
|
-
:param pulumi.Input['CELDeviceSelectorArgs'] cel: CEL contains a CEL expression for selecting a device.
|
|
4562
|
+
Effect indicates the taint effect to match. Empty means match all taint effects. When specified, allowed values are NoSchedule and NoExecute.
|
|
2378
4563
|
"""
|
|
2379
|
-
|
|
2380
|
-
|
|
4564
|
+
return pulumi.get(self, "effect")
|
|
4565
|
+
|
|
4566
|
+
@effect.setter
|
|
4567
|
+
def effect(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
4568
|
+
pulumi.set(self, "effect", value)
|
|
2381
4569
|
|
|
2382
4570
|
@property
|
|
2383
4571
|
@pulumi.getter
|
|
2384
|
-
def
|
|
4572
|
+
def key(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
2385
4573
|
"""
|
|
2386
|
-
|
|
4574
|
+
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.
|
|
2387
4575
|
"""
|
|
2388
|
-
return pulumi.get(self, "
|
|
4576
|
+
return pulumi.get(self, "key")
|
|
2389
4577
|
|
|
2390
|
-
@
|
|
2391
|
-
def
|
|
2392
|
-
pulumi.set(self, "
|
|
4578
|
+
@key.setter
|
|
4579
|
+
def key(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
4580
|
+
pulumi.set(self, "key", value)
|
|
4581
|
+
|
|
4582
|
+
@property
|
|
4583
|
+
@pulumi.getter
|
|
4584
|
+
def operator(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
4585
|
+
"""
|
|
4586
|
+
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.
|
|
4587
|
+
"""
|
|
4588
|
+
return pulumi.get(self, "operator")
|
|
4589
|
+
|
|
4590
|
+
@operator.setter
|
|
4591
|
+
def operator(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
4592
|
+
pulumi.set(self, "operator", value)
|
|
4593
|
+
|
|
4594
|
+
@property
|
|
4595
|
+
@pulumi.getter(name="tolerationSeconds")
|
|
4596
|
+
def toleration_seconds(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
4597
|
+
"""
|
|
4598
|
+
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>.
|
|
4599
|
+
"""
|
|
4600
|
+
return pulumi.get(self, "toleration_seconds")
|
|
4601
|
+
|
|
4602
|
+
@toleration_seconds.setter
|
|
4603
|
+
def toleration_seconds(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
4604
|
+
pulumi.set(self, "toleration_seconds", value)
|
|
4605
|
+
|
|
4606
|
+
@property
|
|
4607
|
+
@pulumi.getter
|
|
4608
|
+
def value(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
4609
|
+
"""
|
|
4610
|
+
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.
|
|
4611
|
+
"""
|
|
4612
|
+
return pulumi.get(self, "value")
|
|
4613
|
+
|
|
4614
|
+
@value.setter
|
|
4615
|
+
def value(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
4616
|
+
pulumi.set(self, "value", value)
|
|
2393
4617
|
|
|
2394
4618
|
|
|
2395
4619
|
if not MYPY:
|
|
@@ -2467,6 +4691,8 @@ if not MYPY:
|
|
|
2467
4691
|
ips: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
|
|
2468
4692
|
"""
|
|
2469
4693
|
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.
|
|
4694
|
+
|
|
4695
|
+
Must not contain more than 16 entries.
|
|
2470
4696
|
"""
|
|
2471
4697
|
elif False:
|
|
2472
4698
|
NetworkDeviceDataArgsDict: TypeAlias = Mapping[str, Any]
|
|
@@ -2486,6 +4712,8 @@ class NetworkDeviceDataArgs:
|
|
|
2486
4712
|
|
|
2487
4713
|
Must not be longer than 256 characters.
|
|
2488
4714
|
: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.
|
|
4715
|
+
|
|
4716
|
+
Must not contain more than 16 entries.
|
|
2489
4717
|
"""
|
|
2490
4718
|
if hardware_address is not None:
|
|
2491
4719
|
pulumi.set(__self__, "hardware_address", hardware_address)
|
|
@@ -2527,6 +4755,8 @@ class NetworkDeviceDataArgs:
|
|
|
2527
4755
|
def ips(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
2528
4756
|
"""
|
|
2529
4757
|
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.
|
|
4758
|
+
|
|
4759
|
+
Must not contain more than 16 entries.
|
|
2530
4760
|
"""
|
|
2531
4761
|
return pulumi.get(self, "ips")
|
|
2532
4762
|
|
|
@@ -3279,7 +5509,7 @@ if not MYPY:
|
|
|
3279
5509
|
|
|
3280
5510
|
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.
|
|
3281
5511
|
|
|
3282
|
-
There can be at most
|
|
5512
|
+
There can be at most 256 such reservations. This may get increased in the future, but not reduced.
|
|
3283
5513
|
"""
|
|
3284
5514
|
elif False:
|
|
3285
5515
|
ResourceClaimStatusArgsDict: TypeAlias = Mapping[str, Any]
|
|
@@ -3306,7 +5536,7 @@ class ResourceClaimStatusArgs:
|
|
|
3306
5536
|
|
|
3307
5537
|
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.
|
|
3308
5538
|
|
|
3309
|
-
There can be at most
|
|
5539
|
+
There can be at most 256 such reservations. This may get increased in the future, but not reduced.
|
|
3310
5540
|
"""
|
|
3311
5541
|
if allocation is not None:
|
|
3312
5542
|
pulumi.set(__self__, "allocation", allocation)
|
|
@@ -3367,7 +5597,7 @@ class ResourceClaimStatusArgs:
|
|
|
3367
5597
|
|
|
3368
5598
|
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.
|
|
3369
5599
|
|
|
3370
|
-
There can be at most
|
|
5600
|
+
There can be at most 256 such reservations. This may get increased in the future, but not reduced.
|
|
3371
5601
|
"""
|
|
3372
5602
|
return pulumi.get(self, "reserved_for")
|
|
3373
5603
|
|
|
@@ -3905,7 +6135,7 @@ if not MYPY:
|
|
|
3905
6135
|
"""
|
|
3906
6136
|
AllNodes indicates that all nodes have access to the resources in the pool.
|
|
3907
6137
|
|
|
3908
|
-
Exactly one of NodeName, NodeSelector and
|
|
6138
|
+
Exactly one of NodeName, NodeSelector, AllNodes, and PerDeviceNodeSelection must be set.
|
|
3909
6139
|
"""
|
|
3910
6140
|
devices: NotRequired[pulumi.Input[Sequence[pulumi.Input['DevicePatchArgsDict']]]]
|
|
3911
6141
|
"""
|
|
@@ -3925,7 +6155,7 @@ if not MYPY:
|
|
|
3925
6155
|
|
|
3926
6156
|
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.
|
|
3927
6157
|
|
|
3928
|
-
Exactly one of NodeName, NodeSelector and
|
|
6158
|
+
Exactly one of NodeName, NodeSelector, AllNodes, and PerDeviceNodeSelection must be set. This field is immutable.
|
|
3929
6159
|
"""
|
|
3930
6160
|
node_selector: NotRequired[pulumi.Input['_core.v1.NodeSelectorPatchArgsDict']]
|
|
3931
6161
|
"""
|
|
@@ -3933,12 +6163,26 @@ if not MYPY:
|
|
|
3933
6163
|
|
|
3934
6164
|
Must use exactly one term.
|
|
3935
6165
|
|
|
3936
|
-
Exactly one of NodeName, NodeSelector and
|
|
6166
|
+
Exactly one of NodeName, NodeSelector, AllNodes, and PerDeviceNodeSelection must be set.
|
|
6167
|
+
"""
|
|
6168
|
+
per_device_node_selection: NotRequired[pulumi.Input[builtins.bool]]
|
|
6169
|
+
"""
|
|
6170
|
+
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.
|
|
6171
|
+
|
|
6172
|
+
Exactly one of NodeName, NodeSelector, AllNodes, and PerDeviceNodeSelection must be set.
|
|
3937
6173
|
"""
|
|
3938
6174
|
pool: NotRequired[pulumi.Input['ResourcePoolPatchArgsDict']]
|
|
3939
6175
|
"""
|
|
3940
6176
|
Pool describes the pool that this ResourceSlice belongs to.
|
|
3941
6177
|
"""
|
|
6178
|
+
shared_counters: NotRequired[pulumi.Input[Sequence[pulumi.Input['CounterSetPatchArgsDict']]]]
|
|
6179
|
+
"""
|
|
6180
|
+
SharedCounters defines a list of counter sets, each of which has a name and a list of counters available.
|
|
6181
|
+
|
|
6182
|
+
The names of the SharedCounters must be unique in the ResourceSlice.
|
|
6183
|
+
|
|
6184
|
+
The maximum number of SharedCounters is 32.
|
|
6185
|
+
"""
|
|
3942
6186
|
elif False:
|
|
3943
6187
|
ResourceSliceSpecPatchArgsDict: TypeAlias = Mapping[str, Any]
|
|
3944
6188
|
|
|
@@ -3950,12 +6194,14 @@ class ResourceSliceSpecPatchArgs:
|
|
|
3950
6194
|
driver: Optional[pulumi.Input[builtins.str]] = None,
|
|
3951
6195
|
node_name: Optional[pulumi.Input[builtins.str]] = None,
|
|
3952
6196
|
node_selector: Optional[pulumi.Input['_core.v1.NodeSelectorPatchArgs']] = None,
|
|
3953
|
-
|
|
6197
|
+
per_device_node_selection: Optional[pulumi.Input[builtins.bool]] = None,
|
|
6198
|
+
pool: Optional[pulumi.Input['ResourcePoolPatchArgs']] = None,
|
|
6199
|
+
shared_counters: Optional[pulumi.Input[Sequence[pulumi.Input['CounterSetPatchArgs']]]] = None):
|
|
3954
6200
|
"""
|
|
3955
6201
|
ResourceSliceSpec contains the information published by the driver in one ResourceSlice.
|
|
3956
6202
|
:param pulumi.Input[builtins.bool] all_nodes: AllNodes indicates that all nodes have access to the resources in the pool.
|
|
3957
6203
|
|
|
3958
|
-
Exactly one of NodeName, NodeSelector and
|
|
6204
|
+
Exactly one of NodeName, NodeSelector, AllNodes, and PerDeviceNodeSelection must be set.
|
|
3959
6205
|
:param pulumi.Input[Sequence[pulumi.Input['DevicePatchArgs']]] devices: Devices lists some or all of the devices in this pool.
|
|
3960
6206
|
|
|
3961
6207
|
Must not have more than 128 entries.
|
|
@@ -3966,13 +6212,21 @@ class ResourceSliceSpecPatchArgs:
|
|
|
3966
6212
|
|
|
3967
6213
|
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.
|
|
3968
6214
|
|
|
3969
|
-
Exactly one of NodeName, NodeSelector and
|
|
6215
|
+
Exactly one of NodeName, NodeSelector, AllNodes, and PerDeviceNodeSelection must be set. This field is immutable.
|
|
3970
6216
|
: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.
|
|
3971
6217
|
|
|
3972
6218
|
Must use exactly one term.
|
|
3973
6219
|
|
|
3974
|
-
Exactly one of NodeName, NodeSelector and
|
|
6220
|
+
Exactly one of NodeName, NodeSelector, AllNodes, and PerDeviceNodeSelection must be set.
|
|
6221
|
+
: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.
|
|
6222
|
+
|
|
6223
|
+
Exactly one of NodeName, NodeSelector, AllNodes, and PerDeviceNodeSelection must be set.
|
|
3975
6224
|
:param pulumi.Input['ResourcePoolPatchArgs'] pool: Pool describes the pool that this ResourceSlice belongs to.
|
|
6225
|
+
: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.
|
|
6226
|
+
|
|
6227
|
+
The names of the SharedCounters must be unique in the ResourceSlice.
|
|
6228
|
+
|
|
6229
|
+
The maximum number of SharedCounters is 32.
|
|
3976
6230
|
"""
|
|
3977
6231
|
if all_nodes is not None:
|
|
3978
6232
|
pulumi.set(__self__, "all_nodes", all_nodes)
|
|
@@ -3984,8 +6238,12 @@ class ResourceSliceSpecPatchArgs:
|
|
|
3984
6238
|
pulumi.set(__self__, "node_name", node_name)
|
|
3985
6239
|
if node_selector is not None:
|
|
3986
6240
|
pulumi.set(__self__, "node_selector", node_selector)
|
|
6241
|
+
if per_device_node_selection is not None:
|
|
6242
|
+
pulumi.set(__self__, "per_device_node_selection", per_device_node_selection)
|
|
3987
6243
|
if pool is not None:
|
|
3988
6244
|
pulumi.set(__self__, "pool", pool)
|
|
6245
|
+
if shared_counters is not None:
|
|
6246
|
+
pulumi.set(__self__, "shared_counters", shared_counters)
|
|
3989
6247
|
|
|
3990
6248
|
@property
|
|
3991
6249
|
@pulumi.getter(name="allNodes")
|
|
@@ -3993,7 +6251,7 @@ class ResourceSliceSpecPatchArgs:
|
|
|
3993
6251
|
"""
|
|
3994
6252
|
AllNodes indicates that all nodes have access to the resources in the pool.
|
|
3995
6253
|
|
|
3996
|
-
Exactly one of NodeName, NodeSelector and
|
|
6254
|
+
Exactly one of NodeName, NodeSelector, AllNodes, and PerDeviceNodeSelection must be set.
|
|
3997
6255
|
"""
|
|
3998
6256
|
return pulumi.get(self, "all_nodes")
|
|
3999
6257
|
|
|
@@ -4037,7 +6295,7 @@ class ResourceSliceSpecPatchArgs:
|
|
|
4037
6295
|
|
|
4038
6296
|
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.
|
|
4039
6297
|
|
|
4040
|
-
Exactly one of NodeName, NodeSelector and
|
|
6298
|
+
Exactly one of NodeName, NodeSelector, AllNodes, and PerDeviceNodeSelection must be set. This field is immutable.
|
|
4041
6299
|
"""
|
|
4042
6300
|
return pulumi.get(self, "node_name")
|
|
4043
6301
|
|
|
@@ -4053,7 +6311,7 @@ class ResourceSliceSpecPatchArgs:
|
|
|
4053
6311
|
|
|
4054
6312
|
Must use exactly one term.
|
|
4055
6313
|
|
|
4056
|
-
Exactly one of NodeName, NodeSelector and
|
|
6314
|
+
Exactly one of NodeName, NodeSelector, AllNodes, and PerDeviceNodeSelection must be set.
|
|
4057
6315
|
"""
|
|
4058
6316
|
return pulumi.get(self, "node_selector")
|
|
4059
6317
|
|
|
@@ -4061,6 +6319,20 @@ class ResourceSliceSpecPatchArgs:
|
|
|
4061
6319
|
def node_selector(self, value: Optional[pulumi.Input['_core.v1.NodeSelectorPatchArgs']]):
|
|
4062
6320
|
pulumi.set(self, "node_selector", value)
|
|
4063
6321
|
|
|
6322
|
+
@property
|
|
6323
|
+
@pulumi.getter(name="perDeviceNodeSelection")
|
|
6324
|
+
def per_device_node_selection(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
6325
|
+
"""
|
|
6326
|
+
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.
|
|
6327
|
+
|
|
6328
|
+
Exactly one of NodeName, NodeSelector, AllNodes, and PerDeviceNodeSelection must be set.
|
|
6329
|
+
"""
|
|
6330
|
+
return pulumi.get(self, "per_device_node_selection")
|
|
6331
|
+
|
|
6332
|
+
@per_device_node_selection.setter
|
|
6333
|
+
def per_device_node_selection(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
6334
|
+
pulumi.set(self, "per_device_node_selection", value)
|
|
6335
|
+
|
|
4064
6336
|
@property
|
|
4065
6337
|
@pulumi.getter
|
|
4066
6338
|
def pool(self) -> Optional[pulumi.Input['ResourcePoolPatchArgs']]:
|
|
@@ -4073,6 +6345,22 @@ class ResourceSliceSpecPatchArgs:
|
|
|
4073
6345
|
def pool(self, value: Optional[pulumi.Input['ResourcePoolPatchArgs']]):
|
|
4074
6346
|
pulumi.set(self, "pool", value)
|
|
4075
6347
|
|
|
6348
|
+
@property
|
|
6349
|
+
@pulumi.getter(name="sharedCounters")
|
|
6350
|
+
def shared_counters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['CounterSetPatchArgs']]]]:
|
|
6351
|
+
"""
|
|
6352
|
+
SharedCounters defines a list of counter sets, each of which has a name and a list of counters available.
|
|
6353
|
+
|
|
6354
|
+
The names of the SharedCounters must be unique in the ResourceSlice.
|
|
6355
|
+
|
|
6356
|
+
The maximum number of SharedCounters is 32.
|
|
6357
|
+
"""
|
|
6358
|
+
return pulumi.get(self, "shared_counters")
|
|
6359
|
+
|
|
6360
|
+
@shared_counters.setter
|
|
6361
|
+
def shared_counters(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['CounterSetPatchArgs']]]]):
|
|
6362
|
+
pulumi.set(self, "shared_counters", value)
|
|
6363
|
+
|
|
4076
6364
|
|
|
4077
6365
|
if not MYPY:
|
|
4078
6366
|
class ResourceSliceSpecArgsDict(TypedDict):
|
|
@@ -4093,7 +6381,7 @@ if not MYPY:
|
|
|
4093
6381
|
"""
|
|
4094
6382
|
AllNodes indicates that all nodes have access to the resources in the pool.
|
|
4095
6383
|
|
|
4096
|
-
Exactly one of NodeName, NodeSelector and
|
|
6384
|
+
Exactly one of NodeName, NodeSelector, AllNodes, and PerDeviceNodeSelection must be set.
|
|
4097
6385
|
"""
|
|
4098
6386
|
devices: NotRequired[pulumi.Input[Sequence[pulumi.Input['DeviceArgsDict']]]]
|
|
4099
6387
|
"""
|
|
@@ -4107,7 +6395,7 @@ if not MYPY:
|
|
|
4107
6395
|
|
|
4108
6396
|
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.
|
|
4109
6397
|
|
|
4110
|
-
Exactly one of NodeName, NodeSelector and
|
|
6398
|
+
Exactly one of NodeName, NodeSelector, AllNodes, and PerDeviceNodeSelection must be set. This field is immutable.
|
|
4111
6399
|
"""
|
|
4112
6400
|
node_selector: NotRequired[pulumi.Input['_core.v1.NodeSelectorArgsDict']]
|
|
4113
6401
|
"""
|
|
@@ -4115,7 +6403,21 @@ if not MYPY:
|
|
|
4115
6403
|
|
|
4116
6404
|
Must use exactly one term.
|
|
4117
6405
|
|
|
4118
|
-
Exactly one of NodeName, NodeSelector and
|
|
6406
|
+
Exactly one of NodeName, NodeSelector, AllNodes, and PerDeviceNodeSelection must be set.
|
|
6407
|
+
"""
|
|
6408
|
+
per_device_node_selection: NotRequired[pulumi.Input[builtins.bool]]
|
|
6409
|
+
"""
|
|
6410
|
+
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.
|
|
6411
|
+
|
|
6412
|
+
Exactly one of NodeName, NodeSelector, AllNodes, and PerDeviceNodeSelection must be set.
|
|
6413
|
+
"""
|
|
6414
|
+
shared_counters: NotRequired[pulumi.Input[Sequence[pulumi.Input['CounterSetArgsDict']]]]
|
|
6415
|
+
"""
|
|
6416
|
+
SharedCounters defines a list of counter sets, each of which has a name and a list of counters available.
|
|
6417
|
+
|
|
6418
|
+
The names of the SharedCounters must be unique in the ResourceSlice.
|
|
6419
|
+
|
|
6420
|
+
The maximum number of SharedCounters is 32.
|
|
4119
6421
|
"""
|
|
4120
6422
|
elif False:
|
|
4121
6423
|
ResourceSliceSpecArgsDict: TypeAlias = Mapping[str, Any]
|
|
@@ -4128,7 +6430,9 @@ class ResourceSliceSpecArgs:
|
|
|
4128
6430
|
all_nodes: Optional[pulumi.Input[builtins.bool]] = None,
|
|
4129
6431
|
devices: Optional[pulumi.Input[Sequence[pulumi.Input['DeviceArgs']]]] = None,
|
|
4130
6432
|
node_name: Optional[pulumi.Input[builtins.str]] = None,
|
|
4131
|
-
node_selector: Optional[pulumi.Input['_core.v1.NodeSelectorArgs']] = None
|
|
6433
|
+
node_selector: Optional[pulumi.Input['_core.v1.NodeSelectorArgs']] = None,
|
|
6434
|
+
per_device_node_selection: Optional[pulumi.Input[builtins.bool]] = None,
|
|
6435
|
+
shared_counters: Optional[pulumi.Input[Sequence[pulumi.Input['CounterSetArgs']]]] = None):
|
|
4132
6436
|
"""
|
|
4133
6437
|
ResourceSliceSpec contains the information published by the driver in one ResourceSlice.
|
|
4134
6438
|
: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.
|
|
@@ -4137,7 +6441,7 @@ class ResourceSliceSpecArgs:
|
|
|
4137
6441
|
:param pulumi.Input['ResourcePoolArgs'] pool: Pool describes the pool that this ResourceSlice belongs to.
|
|
4138
6442
|
:param pulumi.Input[builtins.bool] all_nodes: AllNodes indicates that all nodes have access to the resources in the pool.
|
|
4139
6443
|
|
|
4140
|
-
Exactly one of NodeName, NodeSelector and
|
|
6444
|
+
Exactly one of NodeName, NodeSelector, AllNodes, and PerDeviceNodeSelection must be set.
|
|
4141
6445
|
:param pulumi.Input[Sequence[pulumi.Input['DeviceArgs']]] devices: Devices lists some or all of the devices in this pool.
|
|
4142
6446
|
|
|
4143
6447
|
Must not have more than 128 entries.
|
|
@@ -4145,12 +6449,20 @@ class ResourceSliceSpecArgs:
|
|
|
4145
6449
|
|
|
4146
6450
|
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.
|
|
4147
6451
|
|
|
4148
|
-
Exactly one of NodeName, NodeSelector and
|
|
6452
|
+
Exactly one of NodeName, NodeSelector, AllNodes, and PerDeviceNodeSelection must be set. This field is immutable.
|
|
4149
6453
|
: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.
|
|
4150
6454
|
|
|
4151
6455
|
Must use exactly one term.
|
|
4152
6456
|
|
|
4153
|
-
Exactly one of NodeName, NodeSelector and
|
|
6457
|
+
Exactly one of NodeName, NodeSelector, AllNodes, and PerDeviceNodeSelection must be set.
|
|
6458
|
+
: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.
|
|
6459
|
+
|
|
6460
|
+
Exactly one of NodeName, NodeSelector, AllNodes, and PerDeviceNodeSelection must be set.
|
|
6461
|
+
: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.
|
|
6462
|
+
|
|
6463
|
+
The names of the SharedCounters must be unique in the ResourceSlice.
|
|
6464
|
+
|
|
6465
|
+
The maximum number of SharedCounters is 32.
|
|
4154
6466
|
"""
|
|
4155
6467
|
pulumi.set(__self__, "driver", driver)
|
|
4156
6468
|
pulumi.set(__self__, "pool", pool)
|
|
@@ -4162,6 +6474,10 @@ class ResourceSliceSpecArgs:
|
|
|
4162
6474
|
pulumi.set(__self__, "node_name", node_name)
|
|
4163
6475
|
if node_selector is not None:
|
|
4164
6476
|
pulumi.set(__self__, "node_selector", node_selector)
|
|
6477
|
+
if per_device_node_selection is not None:
|
|
6478
|
+
pulumi.set(__self__, "per_device_node_selection", per_device_node_selection)
|
|
6479
|
+
if shared_counters is not None:
|
|
6480
|
+
pulumi.set(__self__, "shared_counters", shared_counters)
|
|
4165
6481
|
|
|
4166
6482
|
@property
|
|
4167
6483
|
@pulumi.getter
|
|
@@ -4195,7 +6511,7 @@ class ResourceSliceSpecArgs:
|
|
|
4195
6511
|
"""
|
|
4196
6512
|
AllNodes indicates that all nodes have access to the resources in the pool.
|
|
4197
6513
|
|
|
4198
|
-
Exactly one of NodeName, NodeSelector and
|
|
6514
|
+
Exactly one of NodeName, NodeSelector, AllNodes, and PerDeviceNodeSelection must be set.
|
|
4199
6515
|
"""
|
|
4200
6516
|
return pulumi.get(self, "all_nodes")
|
|
4201
6517
|
|
|
@@ -4225,7 +6541,7 @@ class ResourceSliceSpecArgs:
|
|
|
4225
6541
|
|
|
4226
6542
|
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.
|
|
4227
6543
|
|
|
4228
|
-
Exactly one of NodeName, NodeSelector and
|
|
6544
|
+
Exactly one of NodeName, NodeSelector, AllNodes, and PerDeviceNodeSelection must be set. This field is immutable.
|
|
4229
6545
|
"""
|
|
4230
6546
|
return pulumi.get(self, "node_name")
|
|
4231
6547
|
|
|
@@ -4241,7 +6557,7 @@ class ResourceSliceSpecArgs:
|
|
|
4241
6557
|
|
|
4242
6558
|
Must use exactly one term.
|
|
4243
6559
|
|
|
4244
|
-
Exactly one of NodeName, NodeSelector and
|
|
6560
|
+
Exactly one of NodeName, NodeSelector, AllNodes, and PerDeviceNodeSelection must be set.
|
|
4245
6561
|
"""
|
|
4246
6562
|
return pulumi.get(self, "node_selector")
|
|
4247
6563
|
|
|
@@ -4249,6 +6565,36 @@ class ResourceSliceSpecArgs:
|
|
|
4249
6565
|
def node_selector(self, value: Optional[pulumi.Input['_core.v1.NodeSelectorArgs']]):
|
|
4250
6566
|
pulumi.set(self, "node_selector", value)
|
|
4251
6567
|
|
|
6568
|
+
@property
|
|
6569
|
+
@pulumi.getter(name="perDeviceNodeSelection")
|
|
6570
|
+
def per_device_node_selection(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
6571
|
+
"""
|
|
6572
|
+
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.
|
|
6573
|
+
|
|
6574
|
+
Exactly one of NodeName, NodeSelector, AllNodes, and PerDeviceNodeSelection must be set.
|
|
6575
|
+
"""
|
|
6576
|
+
return pulumi.get(self, "per_device_node_selection")
|
|
6577
|
+
|
|
6578
|
+
@per_device_node_selection.setter
|
|
6579
|
+
def per_device_node_selection(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
6580
|
+
pulumi.set(self, "per_device_node_selection", value)
|
|
6581
|
+
|
|
6582
|
+
@property
|
|
6583
|
+
@pulumi.getter(name="sharedCounters")
|
|
6584
|
+
def shared_counters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['CounterSetArgs']]]]:
|
|
6585
|
+
"""
|
|
6586
|
+
SharedCounters defines a list of counter sets, each of which has a name and a list of counters available.
|
|
6587
|
+
|
|
6588
|
+
The names of the SharedCounters must be unique in the ResourceSlice.
|
|
6589
|
+
|
|
6590
|
+
The maximum number of SharedCounters is 32.
|
|
6591
|
+
"""
|
|
6592
|
+
return pulumi.get(self, "shared_counters")
|
|
6593
|
+
|
|
6594
|
+
@shared_counters.setter
|
|
6595
|
+
def shared_counters(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['CounterSetArgs']]]]):
|
|
6596
|
+
pulumi.set(self, "shared_counters", value)
|
|
6597
|
+
|
|
4252
6598
|
|
|
4253
6599
|
if not MYPY:
|
|
4254
6600
|
class ResourceSliceArgsDict(TypedDict):
|