body_hash
stringlengths 64
64
| body
stringlengths 23
109k
| docstring
stringlengths 1
57k
| path
stringlengths 4
198
| name
stringlengths 1
115
| repository_name
stringlengths 7
111
| repository_stars
float64 0
191k
| lang
stringclasses 1
value | body_without_docstring
stringlengths 14
108k
| unified
stringlengths 45
133k
|
|---|---|---|---|---|---|---|---|---|---|
bf5e44d0e580083b08c3f5d19b06e03c46a981848dd902f10b7e1e615be95e67
|
def __init__(__self__, *, key: pulumi.Input[str], operator: pulumi.Input[str], values: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None):
"\n A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.\n :param pulumi.Input[str] key: The label key that the selector applies to.\n :param pulumi.Input[str] operator: Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] values: An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.\n "
pulumi.set(__self__, 'key', key)
pulumi.set(__self__, 'operator', operator)
if (values is not None):
pulumi.set(__self__, 'values', values)
|
A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
:param pulumi.Input[str] key: The label key that the selector applies to.
:param pulumi.Input[str] operator: Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.
:param pulumi.Input[Sequence[pulumi.Input[str]]] values: An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
__init__
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
def __init__(__self__, *, key: pulumi.Input[str], operator: pulumi.Input[str], values: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None):
"\n A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.\n :param pulumi.Input[str] key: The label key that the selector applies to.\n :param pulumi.Input[str] operator: Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] values: An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.\n "
pulumi.set(__self__, 'key', key)
pulumi.set(__self__, 'operator', operator)
if (values is not None):
pulumi.set(__self__, 'values', values)
|
def __init__(__self__, *, key: pulumi.Input[str], operator: pulumi.Input[str], values: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None):
"\n A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.\n :param pulumi.Input[str] key: The label key that the selector applies to.\n :param pulumi.Input[str] operator: Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] values: An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.\n "
pulumi.set(__self__, 'key', key)
pulumi.set(__self__, 'operator', operator)
if (values is not None):
pulumi.set(__self__, 'values', values)<|docstring|>A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
:param pulumi.Input[str] key: The label key that the selector applies to.
:param pulumi.Input[str] operator: Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.
:param pulumi.Input[Sequence[pulumi.Input[str]]] values: An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.<|endoftext|>
|
6cf7c8938f7ceca38c2736fba43ed8ef4a46a14b2f0c1c1a3e2847900d0ba1cc
|
@property
@pulumi.getter
def key(self) -> pulumi.Input[str]:
'\n The label key that the selector applies to.\n '
return pulumi.get(self, 'key')
|
The label key that the selector applies to.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
key
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
@property
@pulumi.getter
def key(self) -> pulumi.Input[str]:
'\n \n '
return pulumi.get(self, 'key')
|
@property
@pulumi.getter
def key(self) -> pulumi.Input[str]:
'\n \n '
return pulumi.get(self, 'key')<|docstring|>The label key that the selector applies to.<|endoftext|>
|
026834ef706ec81b0dac6449994d81a644e4e6273652b199546c01310ae542ba
|
@property
@pulumi.getter
def operator(self) -> pulumi.Input[str]:
"\n Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.\n "
return pulumi.get(self, 'operator')
|
Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
operator
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
@property
@pulumi.getter
def operator(self) -> pulumi.Input[str]:
"\n \n "
return pulumi.get(self, 'operator')
|
@property
@pulumi.getter
def operator(self) -> pulumi.Input[str]:
"\n \n "
return pulumi.get(self, 'operator')<|docstring|>Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.<|endoftext|>
|
1156c9e0af0cbb14c25f97914f22f3802e172355689d41403da88d3ce78227b5
|
@property
@pulumi.getter
def values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
'\n An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.\n '
return pulumi.get(self, 'values')
|
An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
values
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
@property
@pulumi.getter
def values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
'\n \n '
return pulumi.get(self, 'values')
|
@property
@pulumi.getter
def values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
'\n \n '
return pulumi.get(self, 'values')<|docstring|>An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.<|endoftext|>
|
845a6f002afdef673bcb75314eb209fda1558130f13bcb6f1200702d873fd2af
|
def __init__(__self__, *, preferred_during_scheduling_ignored_during_execution: Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionArgs']]]]=None, required_during_scheduling_ignored_during_execution: Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionArgs']]]]=None):
'\n Describes pod affinity scheduling rules (e.g. co-locate this pod in the same node, zone, etc. as some other pod(s)).\n :param pulumi.Input[Sequence[pulumi.Input[\'IBMBlockCSISpecControllerAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionArgs\']]] preferred_during_scheduling_ignored_during_execution: The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding "weight" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred.\n :param pulumi.Input[Sequence[pulumi.Input[\'IBMBlockCSISpecControllerAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionArgs\']]] required_during_scheduling_ignored_during_execution: If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied.\n '
if (preferred_during_scheduling_ignored_during_execution is not None):
pulumi.set(__self__, 'preferred_during_scheduling_ignored_during_execution', preferred_during_scheduling_ignored_during_execution)
if (required_during_scheduling_ignored_during_execution is not None):
pulumi.set(__self__, 'required_during_scheduling_ignored_during_execution', required_during_scheduling_ignored_during_execution)
|
Describes pod affinity scheduling rules (e.g. co-locate this pod in the same node, zone, etc. as some other pod(s)).
:param pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionArgs']]] preferred_during_scheduling_ignored_during_execution: The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding "weight" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred.
:param pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionArgs']]] required_during_scheduling_ignored_during_execution: If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
__init__
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
def __init__(__self__, *, preferred_during_scheduling_ignored_during_execution: Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionArgs']]]]=None, required_during_scheduling_ignored_during_execution: Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionArgs']]]]=None):
'\n Describes pod affinity scheduling rules (e.g. co-locate this pod in the same node, zone, etc. as some other pod(s)).\n :param pulumi.Input[Sequence[pulumi.Input[\'IBMBlockCSISpecControllerAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionArgs\']]] preferred_during_scheduling_ignored_during_execution: The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding "weight" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred.\n :param pulumi.Input[Sequence[pulumi.Input[\'IBMBlockCSISpecControllerAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionArgs\']]] required_during_scheduling_ignored_during_execution: If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied.\n '
if (preferred_during_scheduling_ignored_during_execution is not None):
pulumi.set(__self__, 'preferred_during_scheduling_ignored_during_execution', preferred_during_scheduling_ignored_during_execution)
if (required_during_scheduling_ignored_during_execution is not None):
pulumi.set(__self__, 'required_during_scheduling_ignored_during_execution', required_during_scheduling_ignored_during_execution)
|
def __init__(__self__, *, preferred_during_scheduling_ignored_during_execution: Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionArgs']]]]=None, required_during_scheduling_ignored_during_execution: Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionArgs']]]]=None):
'\n Describes pod affinity scheduling rules (e.g. co-locate this pod in the same node, zone, etc. as some other pod(s)).\n :param pulumi.Input[Sequence[pulumi.Input[\'IBMBlockCSISpecControllerAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionArgs\']]] preferred_during_scheduling_ignored_during_execution: The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding "weight" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred.\n :param pulumi.Input[Sequence[pulumi.Input[\'IBMBlockCSISpecControllerAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionArgs\']]] required_during_scheduling_ignored_during_execution: If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied.\n '
if (preferred_during_scheduling_ignored_during_execution is not None):
pulumi.set(__self__, 'preferred_during_scheduling_ignored_during_execution', preferred_during_scheduling_ignored_during_execution)
if (required_during_scheduling_ignored_during_execution is not None):
pulumi.set(__self__, 'required_during_scheduling_ignored_during_execution', required_during_scheduling_ignored_during_execution)<|docstring|>Describes pod affinity scheduling rules (e.g. co-locate this pod in the same node, zone, etc. as some other pod(s)).
:param pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionArgs']]] preferred_during_scheduling_ignored_during_execution: The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding "weight" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred.
:param pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionArgs']]] required_during_scheduling_ignored_during_execution: If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied.<|endoftext|>
|
ea5d6219c8fbb28999e2d592ce94921a27cb4cb4abf1e8fce4e245bbc0b6f0ee
|
@property
@pulumi.getter(name='preferredDuringSchedulingIgnoredDuringExecution')
def preferred_during_scheduling_ignored_during_execution(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionArgs']]]]:
'\n The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding "weight" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred.\n '
return pulumi.get(self, 'preferred_during_scheduling_ignored_during_execution')
|
The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding "weight" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
preferred_during_scheduling_ignored_during_execution
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
@property
@pulumi.getter(name='preferredDuringSchedulingIgnoredDuringExecution')
def preferred_during_scheduling_ignored_during_execution(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionArgs']]]]:
'\n \n '
return pulumi.get(self, 'preferred_during_scheduling_ignored_during_execution')
|
@property
@pulumi.getter(name='preferredDuringSchedulingIgnoredDuringExecution')
def preferred_during_scheduling_ignored_during_execution(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionArgs']]]]:
'\n \n '
return pulumi.get(self, 'preferred_during_scheduling_ignored_during_execution')<|docstring|>The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding "weight" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred.<|endoftext|>
|
7a47f9c359c0b7d7d9cd7683a31a27a47d86626142c1546a6eb14c05ad54e588
|
@property
@pulumi.getter(name='requiredDuringSchedulingIgnoredDuringExecution')
def required_during_scheduling_ignored_during_execution(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionArgs']]]]:
'\n If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied.\n '
return pulumi.get(self, 'required_during_scheduling_ignored_during_execution')
|
If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
required_during_scheduling_ignored_during_execution
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
@property
@pulumi.getter(name='requiredDuringSchedulingIgnoredDuringExecution')
def required_during_scheduling_ignored_during_execution(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionArgs']]]]:
'\n \n '
return pulumi.get(self, 'required_during_scheduling_ignored_during_execution')
|
@property
@pulumi.getter(name='requiredDuringSchedulingIgnoredDuringExecution')
def required_during_scheduling_ignored_during_execution(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionArgs']]]]:
'\n \n '
return pulumi.get(self, 'required_during_scheduling_ignored_during_execution')<|docstring|>If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied.<|endoftext|>
|
c0732e7b1e76229e32b5a342be89c5809752371d25cc2eaad1c784de9feb6ea4
|
def __init__(__self__, *, pod_affinity_term: pulumi.Input['IBMBlockCSISpecControllerAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermArgs'], weight: pulumi.Input[int]):
"\n The weights of all of the matched WeightedPodAffinityTerm fields are added per-node to find the most preferred node(s)\n :param pulumi.Input['IBMBlockCSISpecControllerAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermArgs'] pod_affinity_term: Required. A pod affinity term, associated with the corresponding weight.\n :param pulumi.Input[int] weight: weight associated with matching the corresponding podAffinityTerm, in the range 1-100.\n "
pulumi.set(__self__, 'pod_affinity_term', pod_affinity_term)
pulumi.set(__self__, 'weight', weight)
|
The weights of all of the matched WeightedPodAffinityTerm fields are added per-node to find the most preferred node(s)
:param pulumi.Input['IBMBlockCSISpecControllerAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermArgs'] pod_affinity_term: Required. A pod affinity term, associated with the corresponding weight.
:param pulumi.Input[int] weight: weight associated with matching the corresponding podAffinityTerm, in the range 1-100.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
__init__
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
def __init__(__self__, *, pod_affinity_term: pulumi.Input['IBMBlockCSISpecControllerAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermArgs'], weight: pulumi.Input[int]):
"\n The weights of all of the matched WeightedPodAffinityTerm fields are added per-node to find the most preferred node(s)\n :param pulumi.Input['IBMBlockCSISpecControllerAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermArgs'] pod_affinity_term: Required. A pod affinity term, associated with the corresponding weight.\n :param pulumi.Input[int] weight: weight associated with matching the corresponding podAffinityTerm, in the range 1-100.\n "
pulumi.set(__self__, 'pod_affinity_term', pod_affinity_term)
pulumi.set(__self__, 'weight', weight)
|
def __init__(__self__, *, pod_affinity_term: pulumi.Input['IBMBlockCSISpecControllerAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermArgs'], weight: pulumi.Input[int]):
"\n The weights of all of the matched WeightedPodAffinityTerm fields are added per-node to find the most preferred node(s)\n :param pulumi.Input['IBMBlockCSISpecControllerAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermArgs'] pod_affinity_term: Required. A pod affinity term, associated with the corresponding weight.\n :param pulumi.Input[int] weight: weight associated with matching the corresponding podAffinityTerm, in the range 1-100.\n "
pulumi.set(__self__, 'pod_affinity_term', pod_affinity_term)
pulumi.set(__self__, 'weight', weight)<|docstring|>The weights of all of the matched WeightedPodAffinityTerm fields are added per-node to find the most preferred node(s)
:param pulumi.Input['IBMBlockCSISpecControllerAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermArgs'] pod_affinity_term: Required. A pod affinity term, associated with the corresponding weight.
:param pulumi.Input[int] weight: weight associated with matching the corresponding podAffinityTerm, in the range 1-100.<|endoftext|>
|
68ca9c985646ecc6a9758e8dddab7a6770d2ca8afc7480adefd5ce6913349876
|
@property
@pulumi.getter(name='podAffinityTerm')
def pod_affinity_term(self) -> pulumi.Input['IBMBlockCSISpecControllerAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermArgs']:
'\n Required. A pod affinity term, associated with the corresponding weight.\n '
return pulumi.get(self, 'pod_affinity_term')
|
Required. A pod affinity term, associated with the corresponding weight.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
pod_affinity_term
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
@property
@pulumi.getter(name='podAffinityTerm')
def pod_affinity_term(self) -> pulumi.Input['IBMBlockCSISpecControllerAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermArgs']:
'\n \n '
return pulumi.get(self, 'pod_affinity_term')
|
@property
@pulumi.getter(name='podAffinityTerm')
def pod_affinity_term(self) -> pulumi.Input['IBMBlockCSISpecControllerAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermArgs']:
'\n \n '
return pulumi.get(self, 'pod_affinity_term')<|docstring|>Required. A pod affinity term, associated with the corresponding weight.<|endoftext|>
|
cbda27b0cdf343ea47c23ff8abbfa8a96b716aaf51975c7c3ed2982e4a3adb2f
|
@property
@pulumi.getter
def weight(self) -> pulumi.Input[int]:
'\n weight associated with matching the corresponding podAffinityTerm, in the range 1-100.\n '
return pulumi.get(self, 'weight')
|
weight associated with matching the corresponding podAffinityTerm, in the range 1-100.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
weight
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
@property
@pulumi.getter
def weight(self) -> pulumi.Input[int]:
'\n \n '
return pulumi.get(self, 'weight')
|
@property
@pulumi.getter
def weight(self) -> pulumi.Input[int]:
'\n \n '
return pulumi.get(self, 'weight')<|docstring|>weight associated with matching the corresponding podAffinityTerm, in the range 1-100.<|endoftext|>
|
5640359cc28319d541040bdd4643fbe4485f2f7ecfe7e54c82de93dc74dd51c3
|
def __init__(__self__, *, topology_key: pulumi.Input[str], label_selector: Optional[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorArgs']]=None, namespaces: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None):
'\n Required. A pod affinity term, associated with the corresponding weight.\n :param pulumi.Input[str] topology_key: This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed.\n :param pulumi.Input[\'IBMBlockCSISpecControllerAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorArgs\'] label_selector: A label query over a set of resources, in this case pods.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] namespaces: namespaces specifies which namespaces the labelSelector applies to (matches against); null or empty list means "this pod\'s namespace"\n '
pulumi.set(__self__, 'topology_key', topology_key)
if (label_selector is not None):
pulumi.set(__self__, 'label_selector', label_selector)
if (namespaces is not None):
pulumi.set(__self__, 'namespaces', namespaces)
|
Required. A pod affinity term, associated with the corresponding weight.
:param pulumi.Input[str] topology_key: This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed.
:param pulumi.Input['IBMBlockCSISpecControllerAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorArgs'] label_selector: A label query over a set of resources, in this case pods.
:param pulumi.Input[Sequence[pulumi.Input[str]]] namespaces: namespaces specifies which namespaces the labelSelector applies to (matches against); null or empty list means "this pod's namespace"
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
__init__
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
def __init__(__self__, *, topology_key: pulumi.Input[str], label_selector: Optional[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorArgs']]=None, namespaces: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None):
'\n Required. A pod affinity term, associated with the corresponding weight.\n :param pulumi.Input[str] topology_key: This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed.\n :param pulumi.Input[\'IBMBlockCSISpecControllerAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorArgs\'] label_selector: A label query over a set of resources, in this case pods.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] namespaces: namespaces specifies which namespaces the labelSelector applies to (matches against); null or empty list means "this pod\'s namespace"\n '
pulumi.set(__self__, 'topology_key', topology_key)
if (label_selector is not None):
pulumi.set(__self__, 'label_selector', label_selector)
if (namespaces is not None):
pulumi.set(__self__, 'namespaces', namespaces)
|
def __init__(__self__, *, topology_key: pulumi.Input[str], label_selector: Optional[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorArgs']]=None, namespaces: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None):
'\n Required. A pod affinity term, associated with the corresponding weight.\n :param pulumi.Input[str] topology_key: This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed.\n :param pulumi.Input[\'IBMBlockCSISpecControllerAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorArgs\'] label_selector: A label query over a set of resources, in this case pods.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] namespaces: namespaces specifies which namespaces the labelSelector applies to (matches against); null or empty list means "this pod\'s namespace"\n '
pulumi.set(__self__, 'topology_key', topology_key)
if (label_selector is not None):
pulumi.set(__self__, 'label_selector', label_selector)
if (namespaces is not None):
pulumi.set(__self__, 'namespaces', namespaces)<|docstring|>Required. A pod affinity term, associated with the corresponding weight.
:param pulumi.Input[str] topology_key: This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed.
:param pulumi.Input['IBMBlockCSISpecControllerAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorArgs'] label_selector: A label query over a set of resources, in this case pods.
:param pulumi.Input[Sequence[pulumi.Input[str]]] namespaces: namespaces specifies which namespaces the labelSelector applies to (matches against); null or empty list means "this pod's namespace"<|endoftext|>
|
1a7fd32bfbac3e1d1c7b3da8ebc96670c998ac5294448293ae6cf957310d8ab3
|
@property
@pulumi.getter(name='topologyKey')
def topology_key(self) -> pulumi.Input[str]:
'\n This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed.\n '
return pulumi.get(self, 'topology_key')
|
This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
topology_key
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
@property
@pulumi.getter(name='topologyKey')
def topology_key(self) -> pulumi.Input[str]:
'\n \n '
return pulumi.get(self, 'topology_key')
|
@property
@pulumi.getter(name='topologyKey')
def topology_key(self) -> pulumi.Input[str]:
'\n \n '
return pulumi.get(self, 'topology_key')<|docstring|>This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed.<|endoftext|>
|
0807ed11476c2afa4307533a7b9e6e035d64101e99f93394a01a05eaa30a91c4
|
@property
@pulumi.getter(name='labelSelector')
def label_selector(self) -> Optional[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorArgs']]:
'\n A label query over a set of resources, in this case pods.\n '
return pulumi.get(self, 'label_selector')
|
A label query over a set of resources, in this case pods.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
label_selector
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
@property
@pulumi.getter(name='labelSelector')
def label_selector(self) -> Optional[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorArgs']]:
'\n \n '
return pulumi.get(self, 'label_selector')
|
@property
@pulumi.getter(name='labelSelector')
def label_selector(self) -> Optional[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorArgs']]:
'\n \n '
return pulumi.get(self, 'label_selector')<|docstring|>A label query over a set of resources, in this case pods.<|endoftext|>
|
cafaaebd0b2bde715d14eccb6c5349f21790206a44c76155207e11f20235f51a
|
@property
@pulumi.getter
def namespaces(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
'\n namespaces specifies which namespaces the labelSelector applies to (matches against); null or empty list means "this pod\'s namespace"\n '
return pulumi.get(self, 'namespaces')
|
namespaces specifies which namespaces the labelSelector applies to (matches against); null or empty list means "this pod's namespace"
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
namespaces
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
@property
@pulumi.getter
def namespaces(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
'\n namespaces specifies which namespaces the labelSelector applies to (matches against); null or empty list means "this pod\'s namespace"\n '
return pulumi.get(self, 'namespaces')
|
@property
@pulumi.getter
def namespaces(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
'\n namespaces specifies which namespaces the labelSelector applies to (matches against); null or empty list means "this pod\'s namespace"\n '
return pulumi.get(self, 'namespaces')<|docstring|>namespaces specifies which namespaces the labelSelector applies to (matches against); null or empty list means "this pod's namespace"<|endoftext|>
|
f4e49d4a02f88f25f263c0ba1eff4de39305d8b1681e405b7933d53c3460578e
|
def __init__(__self__, *, match_expressions: Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressionsArgs']]]]=None, match_labels: Optional[pulumi.Input[Mapping[(str, pulumi.Input[str])]]]=None):
'\n A label query over a set of resources, in this case pods.\n :param pulumi.Input[Sequence[pulumi.Input[\'IBMBlockCSISpecControllerAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressionsArgs\']]] match_expressions: matchExpressions is a list of label selector requirements. The requirements are ANDed.\n :param pulumi.Input[Mapping[str, pulumi.Input[str]]] match_labels: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.\n '
if (match_expressions is not None):
pulumi.set(__self__, 'match_expressions', match_expressions)
if (match_labels is not None):
pulumi.set(__self__, 'match_labels', match_labels)
|
A label query over a set of resources, in this case pods.
:param pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressionsArgs']]] match_expressions: matchExpressions is a list of label selector requirements. The requirements are ANDed.
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] match_labels: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
__init__
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
def __init__(__self__, *, match_expressions: Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressionsArgs']]]]=None, match_labels: Optional[pulumi.Input[Mapping[(str, pulumi.Input[str])]]]=None):
'\n A label query over a set of resources, in this case pods.\n :param pulumi.Input[Sequence[pulumi.Input[\'IBMBlockCSISpecControllerAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressionsArgs\']]] match_expressions: matchExpressions is a list of label selector requirements. The requirements are ANDed.\n :param pulumi.Input[Mapping[str, pulumi.Input[str]]] match_labels: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.\n '
if (match_expressions is not None):
pulumi.set(__self__, 'match_expressions', match_expressions)
if (match_labels is not None):
pulumi.set(__self__, 'match_labels', match_labels)
|
def __init__(__self__, *, match_expressions: Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressionsArgs']]]]=None, match_labels: Optional[pulumi.Input[Mapping[(str, pulumi.Input[str])]]]=None):
'\n A label query over a set of resources, in this case pods.\n :param pulumi.Input[Sequence[pulumi.Input[\'IBMBlockCSISpecControllerAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressionsArgs\']]] match_expressions: matchExpressions is a list of label selector requirements. The requirements are ANDed.\n :param pulumi.Input[Mapping[str, pulumi.Input[str]]] match_labels: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.\n '
if (match_expressions is not None):
pulumi.set(__self__, 'match_expressions', match_expressions)
if (match_labels is not None):
pulumi.set(__self__, 'match_labels', match_labels)<|docstring|>A label query over a set of resources, in this case pods.
:param pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressionsArgs']]] match_expressions: matchExpressions is a list of label selector requirements. The requirements are ANDed.
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] match_labels: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.<|endoftext|>
|
4a2ed11a9d3e914c2e4cd8b2f94deb23b774b5ed95fdf49b7603813ae0e5ec89
|
@property
@pulumi.getter(name='matchExpressions')
def match_expressions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressionsArgs']]]]:
'\n matchExpressions is a list of label selector requirements. The requirements are ANDed.\n '
return pulumi.get(self, 'match_expressions')
|
matchExpressions is a list of label selector requirements. The requirements are ANDed.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
match_expressions
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
@property
@pulumi.getter(name='matchExpressions')
def match_expressions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressionsArgs']]]]:
'\n \n '
return pulumi.get(self, 'match_expressions')
|
@property
@pulumi.getter(name='matchExpressions')
def match_expressions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressionsArgs']]]]:
'\n \n '
return pulumi.get(self, 'match_expressions')<|docstring|>matchExpressions is a list of label selector requirements. The requirements are ANDed.<|endoftext|>
|
c8d28c22c7664eea6a56b076ef07546eb4ceb965de2e9c944999569f79409a76
|
@property
@pulumi.getter(name='matchLabels')
def match_labels(self) -> Optional[pulumi.Input[Mapping[(str, pulumi.Input[str])]]]:
'\n matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.\n '
return pulumi.get(self, 'match_labels')
|
matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
match_labels
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
@property
@pulumi.getter(name='matchLabels')
def match_labels(self) -> Optional[pulumi.Input[Mapping[(str, pulumi.Input[str])]]]:
'\n \n '
return pulumi.get(self, 'match_labels')
|
@property
@pulumi.getter(name='matchLabels')
def match_labels(self) -> Optional[pulumi.Input[Mapping[(str, pulumi.Input[str])]]]:
'\n \n '
return pulumi.get(self, 'match_labels')<|docstring|>matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.<|endoftext|>
|
c920819fc0b4fc3fe978eacb8fbb8d5f1500cc63d1fed6bf3274b88c2f2ce017
|
def __init__(__self__, *, key: pulumi.Input[str], operator: pulumi.Input[str], values: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None):
"\n A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.\n :param pulumi.Input[str] key: key is the label key that the selector applies to.\n :param pulumi.Input[str] operator: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] values: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.\n "
pulumi.set(__self__, 'key', key)
pulumi.set(__self__, 'operator', operator)
if (values is not None):
pulumi.set(__self__, 'values', values)
|
A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
:param pulumi.Input[str] key: key is the label key that the selector applies to.
:param pulumi.Input[str] operator: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.
:param pulumi.Input[Sequence[pulumi.Input[str]]] values: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
__init__
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
def __init__(__self__, *, key: pulumi.Input[str], operator: pulumi.Input[str], values: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None):
"\n A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.\n :param pulumi.Input[str] key: key is the label key that the selector applies to.\n :param pulumi.Input[str] operator: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] values: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.\n "
pulumi.set(__self__, 'key', key)
pulumi.set(__self__, 'operator', operator)
if (values is not None):
pulumi.set(__self__, 'values', values)
|
def __init__(__self__, *, key: pulumi.Input[str], operator: pulumi.Input[str], values: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None):
"\n A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.\n :param pulumi.Input[str] key: key is the label key that the selector applies to.\n :param pulumi.Input[str] operator: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] values: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.\n "
pulumi.set(__self__, 'key', key)
pulumi.set(__self__, 'operator', operator)
if (values is not None):
pulumi.set(__self__, 'values', values)<|docstring|>A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
:param pulumi.Input[str] key: key is the label key that the selector applies to.
:param pulumi.Input[str] operator: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.
:param pulumi.Input[Sequence[pulumi.Input[str]]] values: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.<|endoftext|>
|
873b01de6c7b4b390af7286e21dc936c9a738bde5f172c97010521d8ead34b94
|
@property
@pulumi.getter
def key(self) -> pulumi.Input[str]:
'\n key is the label key that the selector applies to.\n '
return pulumi.get(self, 'key')
|
key is the label key that the selector applies to.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
key
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
@property
@pulumi.getter
def key(self) -> pulumi.Input[str]:
'\n \n '
return pulumi.get(self, 'key')
|
@property
@pulumi.getter
def key(self) -> pulumi.Input[str]:
'\n \n '
return pulumi.get(self, 'key')<|docstring|>key is the label key that the selector applies to.<|endoftext|>
|
0c4e49e08176a0283877710e6179293ccac4fbb9a05b090e0d01b0bc406ff63f
|
@property
@pulumi.getter
def operator(self) -> pulumi.Input[str]:
"\n operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.\n "
return pulumi.get(self, 'operator')
|
operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
operator
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
@property
@pulumi.getter
def operator(self) -> pulumi.Input[str]:
"\n \n "
return pulumi.get(self, 'operator')
|
@property
@pulumi.getter
def operator(self) -> pulumi.Input[str]:
"\n \n "
return pulumi.get(self, 'operator')<|docstring|>operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.<|endoftext|>
|
8890282f9ab13c97f11910757bc10d16f9baa2504cd65573fd75ceafa57e1daf
|
@property
@pulumi.getter
def values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
'\n values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.\n '
return pulumi.get(self, 'values')
|
values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
values
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
@property
@pulumi.getter
def values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
'\n \n '
return pulumi.get(self, 'values')
|
@property
@pulumi.getter
def values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
'\n \n '
return pulumi.get(self, 'values')<|docstring|>values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.<|endoftext|>
|
e0728418fc2acc3ef1da5f50631dae56aa142ea1a86660d0fddc0415fe7e49df
|
def __init__(__self__, *, topology_key: pulumi.Input[str], label_selector: Optional[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorArgs']]=None, namespaces: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None):
'\n Defines a set of pods (namely those matching the labelSelector relative to the given namespace(s)) that this pod should be co-located (affinity) or not co-located (anti-affinity) with, where co-located is defined as running on a node whose value of the label with key <topologyKey> matches that of any node on which a pod of the set of pods is running\n :param pulumi.Input[str] topology_key: This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed.\n :param pulumi.Input[\'IBMBlockCSISpecControllerAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorArgs\'] label_selector: A label query over a set of resources, in this case pods.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] namespaces: namespaces specifies which namespaces the labelSelector applies to (matches against); null or empty list means "this pod\'s namespace"\n '
pulumi.set(__self__, 'topology_key', topology_key)
if (label_selector is not None):
pulumi.set(__self__, 'label_selector', label_selector)
if (namespaces is not None):
pulumi.set(__self__, 'namespaces', namespaces)
|
Defines a set of pods (namely those matching the labelSelector relative to the given namespace(s)) that this pod should be co-located (affinity) or not co-located (anti-affinity) with, where co-located is defined as running on a node whose value of the label with key <topologyKey> matches that of any node on which a pod of the set of pods is running
:param pulumi.Input[str] topology_key: This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed.
:param pulumi.Input['IBMBlockCSISpecControllerAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorArgs'] label_selector: A label query over a set of resources, in this case pods.
:param pulumi.Input[Sequence[pulumi.Input[str]]] namespaces: namespaces specifies which namespaces the labelSelector applies to (matches against); null or empty list means "this pod's namespace"
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
__init__
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
def __init__(__self__, *, topology_key: pulumi.Input[str], label_selector: Optional[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorArgs']]=None, namespaces: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None):
'\n Defines a set of pods (namely those matching the labelSelector relative to the given namespace(s)) that this pod should be co-located (affinity) or not co-located (anti-affinity) with, where co-located is defined as running on a node whose value of the label with key <topologyKey> matches that of any node on which a pod of the set of pods is running\n :param pulumi.Input[str] topology_key: This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed.\n :param pulumi.Input[\'IBMBlockCSISpecControllerAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorArgs\'] label_selector: A label query over a set of resources, in this case pods.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] namespaces: namespaces specifies which namespaces the labelSelector applies to (matches against); null or empty list means "this pod\'s namespace"\n '
pulumi.set(__self__, 'topology_key', topology_key)
if (label_selector is not None):
pulumi.set(__self__, 'label_selector', label_selector)
if (namespaces is not None):
pulumi.set(__self__, 'namespaces', namespaces)
|
def __init__(__self__, *, topology_key: pulumi.Input[str], label_selector: Optional[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorArgs']]=None, namespaces: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None):
'\n Defines a set of pods (namely those matching the labelSelector relative to the given namespace(s)) that this pod should be co-located (affinity) or not co-located (anti-affinity) with, where co-located is defined as running on a node whose value of the label with key <topologyKey> matches that of any node on which a pod of the set of pods is running\n :param pulumi.Input[str] topology_key: This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed.\n :param pulumi.Input[\'IBMBlockCSISpecControllerAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorArgs\'] label_selector: A label query over a set of resources, in this case pods.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] namespaces: namespaces specifies which namespaces the labelSelector applies to (matches against); null or empty list means "this pod\'s namespace"\n '
pulumi.set(__self__, 'topology_key', topology_key)
if (label_selector is not None):
pulumi.set(__self__, 'label_selector', label_selector)
if (namespaces is not None):
pulumi.set(__self__, 'namespaces', namespaces)<|docstring|>Defines a set of pods (namely those matching the labelSelector relative to the given namespace(s)) that this pod should be co-located (affinity) or not co-located (anti-affinity) with, where co-located is defined as running on a node whose value of the label with key <topologyKey> matches that of any node on which a pod of the set of pods is running
:param pulumi.Input[str] topology_key: This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed.
:param pulumi.Input['IBMBlockCSISpecControllerAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorArgs'] label_selector: A label query over a set of resources, in this case pods.
:param pulumi.Input[Sequence[pulumi.Input[str]]] namespaces: namespaces specifies which namespaces the labelSelector applies to (matches against); null or empty list means "this pod's namespace"<|endoftext|>
|
1a7fd32bfbac3e1d1c7b3da8ebc96670c998ac5294448293ae6cf957310d8ab3
|
@property
@pulumi.getter(name='topologyKey')
def topology_key(self) -> pulumi.Input[str]:
'\n This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed.\n '
return pulumi.get(self, 'topology_key')
|
This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
topology_key
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
@property
@pulumi.getter(name='topologyKey')
def topology_key(self) -> pulumi.Input[str]:
'\n \n '
return pulumi.get(self, 'topology_key')
|
@property
@pulumi.getter(name='topologyKey')
def topology_key(self) -> pulumi.Input[str]:
'\n \n '
return pulumi.get(self, 'topology_key')<|docstring|>This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed.<|endoftext|>
|
87814902aabd02f3022432eb2ce7f748cb662bcba0eb573b7e0deb0b8b0e42d8
|
@property
@pulumi.getter(name='labelSelector')
def label_selector(self) -> Optional[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorArgs']]:
'\n A label query over a set of resources, in this case pods.\n '
return pulumi.get(self, 'label_selector')
|
A label query over a set of resources, in this case pods.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
label_selector
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
@property
@pulumi.getter(name='labelSelector')
def label_selector(self) -> Optional[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorArgs']]:
'\n \n '
return pulumi.get(self, 'label_selector')
|
@property
@pulumi.getter(name='labelSelector')
def label_selector(self) -> Optional[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorArgs']]:
'\n \n '
return pulumi.get(self, 'label_selector')<|docstring|>A label query over a set of resources, in this case pods.<|endoftext|>
|
cafaaebd0b2bde715d14eccb6c5349f21790206a44c76155207e11f20235f51a
|
@property
@pulumi.getter
def namespaces(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
'\n namespaces specifies which namespaces the labelSelector applies to (matches against); null or empty list means "this pod\'s namespace"\n '
return pulumi.get(self, 'namespaces')
|
namespaces specifies which namespaces the labelSelector applies to (matches against); null or empty list means "this pod's namespace"
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
namespaces
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
@property
@pulumi.getter
def namespaces(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
'\n namespaces specifies which namespaces the labelSelector applies to (matches against); null or empty list means "this pod\'s namespace"\n '
return pulumi.get(self, 'namespaces')
|
@property
@pulumi.getter
def namespaces(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
'\n namespaces specifies which namespaces the labelSelector applies to (matches against); null or empty list means "this pod\'s namespace"\n '
return pulumi.get(self, 'namespaces')<|docstring|>namespaces specifies which namespaces the labelSelector applies to (matches against); null or empty list means "this pod's namespace"<|endoftext|>
|
cb0860a7e1b75fd3f741ebe62e64fac839bb68a7aeedf07550be1663c49b5e6b
|
def __init__(__self__, *, match_expressions: Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressionsArgs']]]]=None, match_labels: Optional[pulumi.Input[Mapping[(str, pulumi.Input[str])]]]=None):
'\n A label query over a set of resources, in this case pods.\n :param pulumi.Input[Sequence[pulumi.Input[\'IBMBlockCSISpecControllerAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressionsArgs\']]] match_expressions: matchExpressions is a list of label selector requirements. The requirements are ANDed.\n :param pulumi.Input[Mapping[str, pulumi.Input[str]]] match_labels: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.\n '
if (match_expressions is not None):
pulumi.set(__self__, 'match_expressions', match_expressions)
if (match_labels is not None):
pulumi.set(__self__, 'match_labels', match_labels)
|
A label query over a set of resources, in this case pods.
:param pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressionsArgs']]] match_expressions: matchExpressions is a list of label selector requirements. The requirements are ANDed.
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] match_labels: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
__init__
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
def __init__(__self__, *, match_expressions: Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressionsArgs']]]]=None, match_labels: Optional[pulumi.Input[Mapping[(str, pulumi.Input[str])]]]=None):
'\n A label query over a set of resources, in this case pods.\n :param pulumi.Input[Sequence[pulumi.Input[\'IBMBlockCSISpecControllerAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressionsArgs\']]] match_expressions: matchExpressions is a list of label selector requirements. The requirements are ANDed.\n :param pulumi.Input[Mapping[str, pulumi.Input[str]]] match_labels: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.\n '
if (match_expressions is not None):
pulumi.set(__self__, 'match_expressions', match_expressions)
if (match_labels is not None):
pulumi.set(__self__, 'match_labels', match_labels)
|
def __init__(__self__, *, match_expressions: Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressionsArgs']]]]=None, match_labels: Optional[pulumi.Input[Mapping[(str, pulumi.Input[str])]]]=None):
'\n A label query over a set of resources, in this case pods.\n :param pulumi.Input[Sequence[pulumi.Input[\'IBMBlockCSISpecControllerAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressionsArgs\']]] match_expressions: matchExpressions is a list of label selector requirements. The requirements are ANDed.\n :param pulumi.Input[Mapping[str, pulumi.Input[str]]] match_labels: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.\n '
if (match_expressions is not None):
pulumi.set(__self__, 'match_expressions', match_expressions)
if (match_labels is not None):
pulumi.set(__self__, 'match_labels', match_labels)<|docstring|>A label query over a set of resources, in this case pods.
:param pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressionsArgs']]] match_expressions: matchExpressions is a list of label selector requirements. The requirements are ANDed.
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] match_labels: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.<|endoftext|>
|
4df2aa94d451723619a061a90e1f1efc7bfec49a4ead240f0b86e3d0762fba1d
|
@property
@pulumi.getter(name='matchExpressions')
def match_expressions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressionsArgs']]]]:
'\n matchExpressions is a list of label selector requirements. The requirements are ANDed.\n '
return pulumi.get(self, 'match_expressions')
|
matchExpressions is a list of label selector requirements. The requirements are ANDed.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
match_expressions
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
@property
@pulumi.getter(name='matchExpressions')
def match_expressions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressionsArgs']]]]:
'\n \n '
return pulumi.get(self, 'match_expressions')
|
@property
@pulumi.getter(name='matchExpressions')
def match_expressions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressionsArgs']]]]:
'\n \n '
return pulumi.get(self, 'match_expressions')<|docstring|>matchExpressions is a list of label selector requirements. The requirements are ANDed.<|endoftext|>
|
c8d28c22c7664eea6a56b076ef07546eb4ceb965de2e9c944999569f79409a76
|
@property
@pulumi.getter(name='matchLabels')
def match_labels(self) -> Optional[pulumi.Input[Mapping[(str, pulumi.Input[str])]]]:
'\n matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.\n '
return pulumi.get(self, 'match_labels')
|
matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
match_labels
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
@property
@pulumi.getter(name='matchLabels')
def match_labels(self) -> Optional[pulumi.Input[Mapping[(str, pulumi.Input[str])]]]:
'\n \n '
return pulumi.get(self, 'match_labels')
|
@property
@pulumi.getter(name='matchLabels')
def match_labels(self) -> Optional[pulumi.Input[Mapping[(str, pulumi.Input[str])]]]:
'\n \n '
return pulumi.get(self, 'match_labels')<|docstring|>matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.<|endoftext|>
|
c920819fc0b4fc3fe978eacb8fbb8d5f1500cc63d1fed6bf3274b88c2f2ce017
|
def __init__(__self__, *, key: pulumi.Input[str], operator: pulumi.Input[str], values: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None):
"\n A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.\n :param pulumi.Input[str] key: key is the label key that the selector applies to.\n :param pulumi.Input[str] operator: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] values: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.\n "
pulumi.set(__self__, 'key', key)
pulumi.set(__self__, 'operator', operator)
if (values is not None):
pulumi.set(__self__, 'values', values)
|
A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
:param pulumi.Input[str] key: key is the label key that the selector applies to.
:param pulumi.Input[str] operator: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.
:param pulumi.Input[Sequence[pulumi.Input[str]]] values: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
__init__
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
def __init__(__self__, *, key: pulumi.Input[str], operator: pulumi.Input[str], values: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None):
"\n A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.\n :param pulumi.Input[str] key: key is the label key that the selector applies to.\n :param pulumi.Input[str] operator: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] values: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.\n "
pulumi.set(__self__, 'key', key)
pulumi.set(__self__, 'operator', operator)
if (values is not None):
pulumi.set(__self__, 'values', values)
|
def __init__(__self__, *, key: pulumi.Input[str], operator: pulumi.Input[str], values: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None):
"\n A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.\n :param pulumi.Input[str] key: key is the label key that the selector applies to.\n :param pulumi.Input[str] operator: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] values: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.\n "
pulumi.set(__self__, 'key', key)
pulumi.set(__self__, 'operator', operator)
if (values is not None):
pulumi.set(__self__, 'values', values)<|docstring|>A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
:param pulumi.Input[str] key: key is the label key that the selector applies to.
:param pulumi.Input[str] operator: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.
:param pulumi.Input[Sequence[pulumi.Input[str]]] values: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.<|endoftext|>
|
873b01de6c7b4b390af7286e21dc936c9a738bde5f172c97010521d8ead34b94
|
@property
@pulumi.getter
def key(self) -> pulumi.Input[str]:
'\n key is the label key that the selector applies to.\n '
return pulumi.get(self, 'key')
|
key is the label key that the selector applies to.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
key
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
@property
@pulumi.getter
def key(self) -> pulumi.Input[str]:
'\n \n '
return pulumi.get(self, 'key')
|
@property
@pulumi.getter
def key(self) -> pulumi.Input[str]:
'\n \n '
return pulumi.get(self, 'key')<|docstring|>key is the label key that the selector applies to.<|endoftext|>
|
0c4e49e08176a0283877710e6179293ccac4fbb9a05b090e0d01b0bc406ff63f
|
@property
@pulumi.getter
def operator(self) -> pulumi.Input[str]:
"\n operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.\n "
return pulumi.get(self, 'operator')
|
operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
operator
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
@property
@pulumi.getter
def operator(self) -> pulumi.Input[str]:
"\n \n "
return pulumi.get(self, 'operator')
|
@property
@pulumi.getter
def operator(self) -> pulumi.Input[str]:
"\n \n "
return pulumi.get(self, 'operator')<|docstring|>operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.<|endoftext|>
|
8890282f9ab13c97f11910757bc10d16f9baa2504cd65573fd75ceafa57e1daf
|
@property
@pulumi.getter
def values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
'\n values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.\n '
return pulumi.get(self, 'values')
|
values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
values
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
@property
@pulumi.getter
def values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
'\n \n '
return pulumi.get(self, 'values')
|
@property
@pulumi.getter
def values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
'\n \n '
return pulumi.get(self, 'values')<|docstring|>values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.<|endoftext|>
|
adb891a92c36dd16cd42e6e881326207d4f4902492a0a14d98676d410f532f39
|
def __init__(__self__, *, preferred_during_scheduling_ignored_during_execution: Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionArgs']]]]=None, required_during_scheduling_ignored_during_execution: Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionArgs']]]]=None):
'\n Describes pod anti-affinity scheduling rules (e.g. avoid putting this pod in the same node, zone, etc. as some other pod(s)).\n :param pulumi.Input[Sequence[pulumi.Input[\'IBMBlockCSISpecControllerAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionArgs\']]] preferred_during_scheduling_ignored_during_execution: The scheduler will prefer to schedule pods to nodes that satisfy the anti-affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling anti-affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding "weight" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred.\n :param pulumi.Input[Sequence[pulumi.Input[\'IBMBlockCSISpecControllerAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionArgs\']]] required_during_scheduling_ignored_during_execution: If the anti-affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the anti-affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied.\n '
if (preferred_during_scheduling_ignored_during_execution is not None):
pulumi.set(__self__, 'preferred_during_scheduling_ignored_during_execution', preferred_during_scheduling_ignored_during_execution)
if (required_during_scheduling_ignored_during_execution is not None):
pulumi.set(__self__, 'required_during_scheduling_ignored_during_execution', required_during_scheduling_ignored_during_execution)
|
Describes pod anti-affinity scheduling rules (e.g. avoid putting this pod in the same node, zone, etc. as some other pod(s)).
:param pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionArgs']]] preferred_during_scheduling_ignored_during_execution: The scheduler will prefer to schedule pods to nodes that satisfy the anti-affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling anti-affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding "weight" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred.
:param pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionArgs']]] required_during_scheduling_ignored_during_execution: If the anti-affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the anti-affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
__init__
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
def __init__(__self__, *, preferred_during_scheduling_ignored_during_execution: Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionArgs']]]]=None, required_during_scheduling_ignored_during_execution: Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionArgs']]]]=None):
'\n Describes pod anti-affinity scheduling rules (e.g. avoid putting this pod in the same node, zone, etc. as some other pod(s)).\n :param pulumi.Input[Sequence[pulumi.Input[\'IBMBlockCSISpecControllerAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionArgs\']]] preferred_during_scheduling_ignored_during_execution: The scheduler will prefer to schedule pods to nodes that satisfy the anti-affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling anti-affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding "weight" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred.\n :param pulumi.Input[Sequence[pulumi.Input[\'IBMBlockCSISpecControllerAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionArgs\']]] required_during_scheduling_ignored_during_execution: If the anti-affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the anti-affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied.\n '
if (preferred_during_scheduling_ignored_during_execution is not None):
pulumi.set(__self__, 'preferred_during_scheduling_ignored_during_execution', preferred_during_scheduling_ignored_during_execution)
if (required_during_scheduling_ignored_during_execution is not None):
pulumi.set(__self__, 'required_during_scheduling_ignored_during_execution', required_during_scheduling_ignored_during_execution)
|
def __init__(__self__, *, preferred_during_scheduling_ignored_during_execution: Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionArgs']]]]=None, required_during_scheduling_ignored_during_execution: Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionArgs']]]]=None):
'\n Describes pod anti-affinity scheduling rules (e.g. avoid putting this pod in the same node, zone, etc. as some other pod(s)).\n :param pulumi.Input[Sequence[pulumi.Input[\'IBMBlockCSISpecControllerAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionArgs\']]] preferred_during_scheduling_ignored_during_execution: The scheduler will prefer to schedule pods to nodes that satisfy the anti-affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling anti-affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding "weight" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred.\n :param pulumi.Input[Sequence[pulumi.Input[\'IBMBlockCSISpecControllerAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionArgs\']]] required_during_scheduling_ignored_during_execution: If the anti-affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the anti-affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied.\n '
if (preferred_during_scheduling_ignored_during_execution is not None):
pulumi.set(__self__, 'preferred_during_scheduling_ignored_during_execution', preferred_during_scheduling_ignored_during_execution)
if (required_during_scheduling_ignored_during_execution is not None):
pulumi.set(__self__, 'required_during_scheduling_ignored_during_execution', required_during_scheduling_ignored_during_execution)<|docstring|>Describes pod anti-affinity scheduling rules (e.g. avoid putting this pod in the same node, zone, etc. as some other pod(s)).
:param pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionArgs']]] preferred_during_scheduling_ignored_during_execution: The scheduler will prefer to schedule pods to nodes that satisfy the anti-affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling anti-affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding "weight" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred.
:param pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionArgs']]] required_during_scheduling_ignored_during_execution: If the anti-affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the anti-affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied.<|endoftext|>
|
39b8496f1f1c719aef0a855bc19a99255bfd644b4c1ccbf37ebb9376c12baffe
|
@property
@pulumi.getter(name='preferredDuringSchedulingIgnoredDuringExecution')
def preferred_during_scheduling_ignored_during_execution(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionArgs']]]]:
'\n The scheduler will prefer to schedule pods to nodes that satisfy the anti-affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling anti-affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding "weight" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred.\n '
return pulumi.get(self, 'preferred_during_scheduling_ignored_during_execution')
|
The scheduler will prefer to schedule pods to nodes that satisfy the anti-affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling anti-affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding "weight" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
preferred_during_scheduling_ignored_during_execution
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
@property
@pulumi.getter(name='preferredDuringSchedulingIgnoredDuringExecution')
def preferred_during_scheduling_ignored_during_execution(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionArgs']]]]:
'\n \n '
return pulumi.get(self, 'preferred_during_scheduling_ignored_during_execution')
|
@property
@pulumi.getter(name='preferredDuringSchedulingIgnoredDuringExecution')
def preferred_during_scheduling_ignored_during_execution(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionArgs']]]]:
'\n \n '
return pulumi.get(self, 'preferred_during_scheduling_ignored_during_execution')<|docstring|>The scheduler will prefer to schedule pods to nodes that satisfy the anti-affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling anti-affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding "weight" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred.<|endoftext|>
|
c2fe18431614e151b637fd4a6e47788389d3c1193e3a718f4651cc88a042fa59
|
@property
@pulumi.getter(name='requiredDuringSchedulingIgnoredDuringExecution')
def required_during_scheduling_ignored_during_execution(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionArgs']]]]:
'\n If the anti-affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the anti-affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied.\n '
return pulumi.get(self, 'required_during_scheduling_ignored_during_execution')
|
If the anti-affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the anti-affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
required_during_scheduling_ignored_during_execution
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
@property
@pulumi.getter(name='requiredDuringSchedulingIgnoredDuringExecution')
def required_during_scheduling_ignored_during_execution(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionArgs']]]]:
'\n \n '
return pulumi.get(self, 'required_during_scheduling_ignored_during_execution')
|
@property
@pulumi.getter(name='requiredDuringSchedulingIgnoredDuringExecution')
def required_during_scheduling_ignored_during_execution(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionArgs']]]]:
'\n \n '
return pulumi.get(self, 'required_during_scheduling_ignored_during_execution')<|docstring|>If the anti-affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the anti-affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied.<|endoftext|>
|
2cbca0fdf2aef7410428bf41bef4e86143cdacf52a9037fb8741f7d1cb8abc54
|
def __init__(__self__, *, pod_affinity_term: pulumi.Input['IBMBlockCSISpecControllerAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermArgs'], weight: pulumi.Input[int]):
"\n The weights of all of the matched WeightedPodAffinityTerm fields are added per-node to find the most preferred node(s)\n :param pulumi.Input['IBMBlockCSISpecControllerAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermArgs'] pod_affinity_term: Required. A pod affinity term, associated with the corresponding weight.\n :param pulumi.Input[int] weight: weight associated with matching the corresponding podAffinityTerm, in the range 1-100.\n "
pulumi.set(__self__, 'pod_affinity_term', pod_affinity_term)
pulumi.set(__self__, 'weight', weight)
|
The weights of all of the matched WeightedPodAffinityTerm fields are added per-node to find the most preferred node(s)
:param pulumi.Input['IBMBlockCSISpecControllerAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermArgs'] pod_affinity_term: Required. A pod affinity term, associated with the corresponding weight.
:param pulumi.Input[int] weight: weight associated with matching the corresponding podAffinityTerm, in the range 1-100.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
__init__
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
def __init__(__self__, *, pod_affinity_term: pulumi.Input['IBMBlockCSISpecControllerAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermArgs'], weight: pulumi.Input[int]):
"\n The weights of all of the matched WeightedPodAffinityTerm fields are added per-node to find the most preferred node(s)\n :param pulumi.Input['IBMBlockCSISpecControllerAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermArgs'] pod_affinity_term: Required. A pod affinity term, associated with the corresponding weight.\n :param pulumi.Input[int] weight: weight associated with matching the corresponding podAffinityTerm, in the range 1-100.\n "
pulumi.set(__self__, 'pod_affinity_term', pod_affinity_term)
pulumi.set(__self__, 'weight', weight)
|
def __init__(__self__, *, pod_affinity_term: pulumi.Input['IBMBlockCSISpecControllerAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermArgs'], weight: pulumi.Input[int]):
"\n The weights of all of the matched WeightedPodAffinityTerm fields are added per-node to find the most preferred node(s)\n :param pulumi.Input['IBMBlockCSISpecControllerAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermArgs'] pod_affinity_term: Required. A pod affinity term, associated with the corresponding weight.\n :param pulumi.Input[int] weight: weight associated with matching the corresponding podAffinityTerm, in the range 1-100.\n "
pulumi.set(__self__, 'pod_affinity_term', pod_affinity_term)
pulumi.set(__self__, 'weight', weight)<|docstring|>The weights of all of the matched WeightedPodAffinityTerm fields are added per-node to find the most preferred node(s)
:param pulumi.Input['IBMBlockCSISpecControllerAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermArgs'] pod_affinity_term: Required. A pod affinity term, associated with the corresponding weight.
:param pulumi.Input[int] weight: weight associated with matching the corresponding podAffinityTerm, in the range 1-100.<|endoftext|>
|
c80e7cf2f63c13cd451793cc73c966d47a016562e3880ffb84a2ce083aa643ab
|
@property
@pulumi.getter(name='podAffinityTerm')
def pod_affinity_term(self) -> pulumi.Input['IBMBlockCSISpecControllerAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermArgs']:
'\n Required. A pod affinity term, associated with the corresponding weight.\n '
return pulumi.get(self, 'pod_affinity_term')
|
Required. A pod affinity term, associated with the corresponding weight.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
pod_affinity_term
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
@property
@pulumi.getter(name='podAffinityTerm')
def pod_affinity_term(self) -> pulumi.Input['IBMBlockCSISpecControllerAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermArgs']:
'\n \n '
return pulumi.get(self, 'pod_affinity_term')
|
@property
@pulumi.getter(name='podAffinityTerm')
def pod_affinity_term(self) -> pulumi.Input['IBMBlockCSISpecControllerAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermArgs']:
'\n \n '
return pulumi.get(self, 'pod_affinity_term')<|docstring|>Required. A pod affinity term, associated with the corresponding weight.<|endoftext|>
|
cbda27b0cdf343ea47c23ff8abbfa8a96b716aaf51975c7c3ed2982e4a3adb2f
|
@property
@pulumi.getter
def weight(self) -> pulumi.Input[int]:
'\n weight associated with matching the corresponding podAffinityTerm, in the range 1-100.\n '
return pulumi.get(self, 'weight')
|
weight associated with matching the corresponding podAffinityTerm, in the range 1-100.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
weight
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
@property
@pulumi.getter
def weight(self) -> pulumi.Input[int]:
'\n \n '
return pulumi.get(self, 'weight')
|
@property
@pulumi.getter
def weight(self) -> pulumi.Input[int]:
'\n \n '
return pulumi.get(self, 'weight')<|docstring|>weight associated with matching the corresponding podAffinityTerm, in the range 1-100.<|endoftext|>
|
6fc8dc663386a6d0de228c524c1bdc8f9386e9b247af8cf7fb65579928950fae
|
def __init__(__self__, *, topology_key: pulumi.Input[str], label_selector: Optional[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorArgs']]=None, namespaces: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None):
'\n Required. A pod affinity term, associated with the corresponding weight.\n :param pulumi.Input[str] topology_key: This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed.\n :param pulumi.Input[\'IBMBlockCSISpecControllerAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorArgs\'] label_selector: A label query over a set of resources, in this case pods.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] namespaces: namespaces specifies which namespaces the labelSelector applies to (matches against); null or empty list means "this pod\'s namespace"\n '
pulumi.set(__self__, 'topology_key', topology_key)
if (label_selector is not None):
pulumi.set(__self__, 'label_selector', label_selector)
if (namespaces is not None):
pulumi.set(__self__, 'namespaces', namespaces)
|
Required. A pod affinity term, associated with the corresponding weight.
:param pulumi.Input[str] topology_key: This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed.
:param pulumi.Input['IBMBlockCSISpecControllerAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorArgs'] label_selector: A label query over a set of resources, in this case pods.
:param pulumi.Input[Sequence[pulumi.Input[str]]] namespaces: namespaces specifies which namespaces the labelSelector applies to (matches against); null or empty list means "this pod's namespace"
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
__init__
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
def __init__(__self__, *, topology_key: pulumi.Input[str], label_selector: Optional[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorArgs']]=None, namespaces: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None):
'\n Required. A pod affinity term, associated with the corresponding weight.\n :param pulumi.Input[str] topology_key: This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed.\n :param pulumi.Input[\'IBMBlockCSISpecControllerAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorArgs\'] label_selector: A label query over a set of resources, in this case pods.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] namespaces: namespaces specifies which namespaces the labelSelector applies to (matches against); null or empty list means "this pod\'s namespace"\n '
pulumi.set(__self__, 'topology_key', topology_key)
if (label_selector is not None):
pulumi.set(__self__, 'label_selector', label_selector)
if (namespaces is not None):
pulumi.set(__self__, 'namespaces', namespaces)
|
def __init__(__self__, *, topology_key: pulumi.Input[str], label_selector: Optional[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorArgs']]=None, namespaces: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None):
'\n Required. A pod affinity term, associated with the corresponding weight.\n :param pulumi.Input[str] topology_key: This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed.\n :param pulumi.Input[\'IBMBlockCSISpecControllerAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorArgs\'] label_selector: A label query over a set of resources, in this case pods.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] namespaces: namespaces specifies which namespaces the labelSelector applies to (matches against); null or empty list means "this pod\'s namespace"\n '
pulumi.set(__self__, 'topology_key', topology_key)
if (label_selector is not None):
pulumi.set(__self__, 'label_selector', label_selector)
if (namespaces is not None):
pulumi.set(__self__, 'namespaces', namespaces)<|docstring|>Required. A pod affinity term, associated with the corresponding weight.
:param pulumi.Input[str] topology_key: This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed.
:param pulumi.Input['IBMBlockCSISpecControllerAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorArgs'] label_selector: A label query over a set of resources, in this case pods.
:param pulumi.Input[Sequence[pulumi.Input[str]]] namespaces: namespaces specifies which namespaces the labelSelector applies to (matches against); null or empty list means "this pod's namespace"<|endoftext|>
|
1a7fd32bfbac3e1d1c7b3da8ebc96670c998ac5294448293ae6cf957310d8ab3
|
@property
@pulumi.getter(name='topologyKey')
def topology_key(self) -> pulumi.Input[str]:
'\n This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed.\n '
return pulumi.get(self, 'topology_key')
|
This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
topology_key
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
@property
@pulumi.getter(name='topologyKey')
def topology_key(self) -> pulumi.Input[str]:
'\n \n '
return pulumi.get(self, 'topology_key')
|
@property
@pulumi.getter(name='topologyKey')
def topology_key(self) -> pulumi.Input[str]:
'\n \n '
return pulumi.get(self, 'topology_key')<|docstring|>This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed.<|endoftext|>
|
64f0cef36bc7cb31b46148e7f49545b2aadbf1ea9545026c0f7ad65ebd6a9c6e
|
@property
@pulumi.getter(name='labelSelector')
def label_selector(self) -> Optional[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorArgs']]:
'\n A label query over a set of resources, in this case pods.\n '
return pulumi.get(self, 'label_selector')
|
A label query over a set of resources, in this case pods.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
label_selector
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
@property
@pulumi.getter(name='labelSelector')
def label_selector(self) -> Optional[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorArgs']]:
'\n \n '
return pulumi.get(self, 'label_selector')
|
@property
@pulumi.getter(name='labelSelector')
def label_selector(self) -> Optional[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorArgs']]:
'\n \n '
return pulumi.get(self, 'label_selector')<|docstring|>A label query over a set of resources, in this case pods.<|endoftext|>
|
cafaaebd0b2bde715d14eccb6c5349f21790206a44c76155207e11f20235f51a
|
@property
@pulumi.getter
def namespaces(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
'\n namespaces specifies which namespaces the labelSelector applies to (matches against); null or empty list means "this pod\'s namespace"\n '
return pulumi.get(self, 'namespaces')
|
namespaces specifies which namespaces the labelSelector applies to (matches against); null or empty list means "this pod's namespace"
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
namespaces
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
@property
@pulumi.getter
def namespaces(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
'\n namespaces specifies which namespaces the labelSelector applies to (matches against); null or empty list means "this pod\'s namespace"\n '
return pulumi.get(self, 'namespaces')
|
@property
@pulumi.getter
def namespaces(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
'\n namespaces specifies which namespaces the labelSelector applies to (matches against); null or empty list means "this pod\'s namespace"\n '
return pulumi.get(self, 'namespaces')<|docstring|>namespaces specifies which namespaces the labelSelector applies to (matches against); null or empty list means "this pod's namespace"<|endoftext|>
|
c8ed38abb563bb064b4b42ef9b51119bec899ff52ccdf63c0494c3cad5836493
|
def __init__(__self__, *, match_expressions: Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressionsArgs']]]]=None, match_labels: Optional[pulumi.Input[Mapping[(str, pulumi.Input[str])]]]=None):
'\n A label query over a set of resources, in this case pods.\n :param pulumi.Input[Sequence[pulumi.Input[\'IBMBlockCSISpecControllerAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressionsArgs\']]] match_expressions: matchExpressions is a list of label selector requirements. The requirements are ANDed.\n :param pulumi.Input[Mapping[str, pulumi.Input[str]]] match_labels: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.\n '
if (match_expressions is not None):
pulumi.set(__self__, 'match_expressions', match_expressions)
if (match_labels is not None):
pulumi.set(__self__, 'match_labels', match_labels)
|
A label query over a set of resources, in this case pods.
:param pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressionsArgs']]] match_expressions: matchExpressions is a list of label selector requirements. The requirements are ANDed.
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] match_labels: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
__init__
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
def __init__(__self__, *, match_expressions: Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressionsArgs']]]]=None, match_labels: Optional[pulumi.Input[Mapping[(str, pulumi.Input[str])]]]=None):
'\n A label query over a set of resources, in this case pods.\n :param pulumi.Input[Sequence[pulumi.Input[\'IBMBlockCSISpecControllerAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressionsArgs\']]] match_expressions: matchExpressions is a list of label selector requirements. The requirements are ANDed.\n :param pulumi.Input[Mapping[str, pulumi.Input[str]]] match_labels: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.\n '
if (match_expressions is not None):
pulumi.set(__self__, 'match_expressions', match_expressions)
if (match_labels is not None):
pulumi.set(__self__, 'match_labels', match_labels)
|
def __init__(__self__, *, match_expressions: Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressionsArgs']]]]=None, match_labels: Optional[pulumi.Input[Mapping[(str, pulumi.Input[str])]]]=None):
'\n A label query over a set of resources, in this case pods.\n :param pulumi.Input[Sequence[pulumi.Input[\'IBMBlockCSISpecControllerAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressionsArgs\']]] match_expressions: matchExpressions is a list of label selector requirements. The requirements are ANDed.\n :param pulumi.Input[Mapping[str, pulumi.Input[str]]] match_labels: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.\n '
if (match_expressions is not None):
pulumi.set(__self__, 'match_expressions', match_expressions)
if (match_labels is not None):
pulumi.set(__self__, 'match_labels', match_labels)<|docstring|>A label query over a set of resources, in this case pods.
:param pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressionsArgs']]] match_expressions: matchExpressions is a list of label selector requirements. The requirements are ANDed.
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] match_labels: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.<|endoftext|>
|
e58eb0ab9f2f5310c4c0ea5ff4465e32166c4614997dd7f36f0ec6623b9ebd42
|
@property
@pulumi.getter(name='matchExpressions')
def match_expressions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressionsArgs']]]]:
'\n matchExpressions is a list of label selector requirements. The requirements are ANDed.\n '
return pulumi.get(self, 'match_expressions')
|
matchExpressions is a list of label selector requirements. The requirements are ANDed.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
match_expressions
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
@property
@pulumi.getter(name='matchExpressions')
def match_expressions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressionsArgs']]]]:
'\n \n '
return pulumi.get(self, 'match_expressions')
|
@property
@pulumi.getter(name='matchExpressions')
def match_expressions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressionsArgs']]]]:
'\n \n '
return pulumi.get(self, 'match_expressions')<|docstring|>matchExpressions is a list of label selector requirements. The requirements are ANDed.<|endoftext|>
|
c8d28c22c7664eea6a56b076ef07546eb4ceb965de2e9c944999569f79409a76
|
@property
@pulumi.getter(name='matchLabels')
def match_labels(self) -> Optional[pulumi.Input[Mapping[(str, pulumi.Input[str])]]]:
'\n matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.\n '
return pulumi.get(self, 'match_labels')
|
matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
match_labels
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
@property
@pulumi.getter(name='matchLabels')
def match_labels(self) -> Optional[pulumi.Input[Mapping[(str, pulumi.Input[str])]]]:
'\n \n '
return pulumi.get(self, 'match_labels')
|
@property
@pulumi.getter(name='matchLabels')
def match_labels(self) -> Optional[pulumi.Input[Mapping[(str, pulumi.Input[str])]]]:
'\n \n '
return pulumi.get(self, 'match_labels')<|docstring|>matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.<|endoftext|>
|
c920819fc0b4fc3fe978eacb8fbb8d5f1500cc63d1fed6bf3274b88c2f2ce017
|
def __init__(__self__, *, key: pulumi.Input[str], operator: pulumi.Input[str], values: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None):
"\n A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.\n :param pulumi.Input[str] key: key is the label key that the selector applies to.\n :param pulumi.Input[str] operator: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] values: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.\n "
pulumi.set(__self__, 'key', key)
pulumi.set(__self__, 'operator', operator)
if (values is not None):
pulumi.set(__self__, 'values', values)
|
A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
:param pulumi.Input[str] key: key is the label key that the selector applies to.
:param pulumi.Input[str] operator: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.
:param pulumi.Input[Sequence[pulumi.Input[str]]] values: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
__init__
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
def __init__(__self__, *, key: pulumi.Input[str], operator: pulumi.Input[str], values: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None):
"\n A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.\n :param pulumi.Input[str] key: key is the label key that the selector applies to.\n :param pulumi.Input[str] operator: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] values: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.\n "
pulumi.set(__self__, 'key', key)
pulumi.set(__self__, 'operator', operator)
if (values is not None):
pulumi.set(__self__, 'values', values)
|
def __init__(__self__, *, key: pulumi.Input[str], operator: pulumi.Input[str], values: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None):
"\n A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.\n :param pulumi.Input[str] key: key is the label key that the selector applies to.\n :param pulumi.Input[str] operator: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] values: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.\n "
pulumi.set(__self__, 'key', key)
pulumi.set(__self__, 'operator', operator)
if (values is not None):
pulumi.set(__self__, 'values', values)<|docstring|>A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
:param pulumi.Input[str] key: key is the label key that the selector applies to.
:param pulumi.Input[str] operator: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.
:param pulumi.Input[Sequence[pulumi.Input[str]]] values: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.<|endoftext|>
|
873b01de6c7b4b390af7286e21dc936c9a738bde5f172c97010521d8ead34b94
|
@property
@pulumi.getter
def key(self) -> pulumi.Input[str]:
'\n key is the label key that the selector applies to.\n '
return pulumi.get(self, 'key')
|
key is the label key that the selector applies to.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
key
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
@property
@pulumi.getter
def key(self) -> pulumi.Input[str]:
'\n \n '
return pulumi.get(self, 'key')
|
@property
@pulumi.getter
def key(self) -> pulumi.Input[str]:
'\n \n '
return pulumi.get(self, 'key')<|docstring|>key is the label key that the selector applies to.<|endoftext|>
|
0c4e49e08176a0283877710e6179293ccac4fbb9a05b090e0d01b0bc406ff63f
|
@property
@pulumi.getter
def operator(self) -> pulumi.Input[str]:
"\n operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.\n "
return pulumi.get(self, 'operator')
|
operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
operator
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
@property
@pulumi.getter
def operator(self) -> pulumi.Input[str]:
"\n \n "
return pulumi.get(self, 'operator')
|
@property
@pulumi.getter
def operator(self) -> pulumi.Input[str]:
"\n \n "
return pulumi.get(self, 'operator')<|docstring|>operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.<|endoftext|>
|
8890282f9ab13c97f11910757bc10d16f9baa2504cd65573fd75ceafa57e1daf
|
@property
@pulumi.getter
def values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
'\n values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.\n '
return pulumi.get(self, 'values')
|
values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
values
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
@property
@pulumi.getter
def values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
'\n \n '
return pulumi.get(self, 'values')
|
@property
@pulumi.getter
def values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
'\n \n '
return pulumi.get(self, 'values')<|docstring|>values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.<|endoftext|>
|
72365dc9fa53896adc8c717feb9bee5fdd549e019e4dbba7af71b07232b621d4
|
def __init__(__self__, *, topology_key: pulumi.Input[str], label_selector: Optional[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorArgs']]=None, namespaces: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None):
'\n Defines a set of pods (namely those matching the labelSelector relative to the given namespace(s)) that this pod should be co-located (affinity) or not co-located (anti-affinity) with, where co-located is defined as running on a node whose value of the label with key <topologyKey> matches that of any node on which a pod of the set of pods is running\n :param pulumi.Input[str] topology_key: This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed.\n :param pulumi.Input[\'IBMBlockCSISpecControllerAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorArgs\'] label_selector: A label query over a set of resources, in this case pods.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] namespaces: namespaces specifies which namespaces the labelSelector applies to (matches against); null or empty list means "this pod\'s namespace"\n '
pulumi.set(__self__, 'topology_key', topology_key)
if (label_selector is not None):
pulumi.set(__self__, 'label_selector', label_selector)
if (namespaces is not None):
pulumi.set(__self__, 'namespaces', namespaces)
|
Defines a set of pods (namely those matching the labelSelector relative to the given namespace(s)) that this pod should be co-located (affinity) or not co-located (anti-affinity) with, where co-located is defined as running on a node whose value of the label with key <topologyKey> matches that of any node on which a pod of the set of pods is running
:param pulumi.Input[str] topology_key: This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed.
:param pulumi.Input['IBMBlockCSISpecControllerAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorArgs'] label_selector: A label query over a set of resources, in this case pods.
:param pulumi.Input[Sequence[pulumi.Input[str]]] namespaces: namespaces specifies which namespaces the labelSelector applies to (matches against); null or empty list means "this pod's namespace"
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
__init__
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
def __init__(__self__, *, topology_key: pulumi.Input[str], label_selector: Optional[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorArgs']]=None, namespaces: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None):
'\n Defines a set of pods (namely those matching the labelSelector relative to the given namespace(s)) that this pod should be co-located (affinity) or not co-located (anti-affinity) with, where co-located is defined as running on a node whose value of the label with key <topologyKey> matches that of any node on which a pod of the set of pods is running\n :param pulumi.Input[str] topology_key: This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed.\n :param pulumi.Input[\'IBMBlockCSISpecControllerAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorArgs\'] label_selector: A label query over a set of resources, in this case pods.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] namespaces: namespaces specifies which namespaces the labelSelector applies to (matches against); null or empty list means "this pod\'s namespace"\n '
pulumi.set(__self__, 'topology_key', topology_key)
if (label_selector is not None):
pulumi.set(__self__, 'label_selector', label_selector)
if (namespaces is not None):
pulumi.set(__self__, 'namespaces', namespaces)
|
def __init__(__self__, *, topology_key: pulumi.Input[str], label_selector: Optional[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorArgs']]=None, namespaces: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None):
'\n Defines a set of pods (namely those matching the labelSelector relative to the given namespace(s)) that this pod should be co-located (affinity) or not co-located (anti-affinity) with, where co-located is defined as running on a node whose value of the label with key <topologyKey> matches that of any node on which a pod of the set of pods is running\n :param pulumi.Input[str] topology_key: This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed.\n :param pulumi.Input[\'IBMBlockCSISpecControllerAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorArgs\'] label_selector: A label query over a set of resources, in this case pods.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] namespaces: namespaces specifies which namespaces the labelSelector applies to (matches against); null or empty list means "this pod\'s namespace"\n '
pulumi.set(__self__, 'topology_key', topology_key)
if (label_selector is not None):
pulumi.set(__self__, 'label_selector', label_selector)
if (namespaces is not None):
pulumi.set(__self__, 'namespaces', namespaces)<|docstring|>Defines a set of pods (namely those matching the labelSelector relative to the given namespace(s)) that this pod should be co-located (affinity) or not co-located (anti-affinity) with, where co-located is defined as running on a node whose value of the label with key <topologyKey> matches that of any node on which a pod of the set of pods is running
:param pulumi.Input[str] topology_key: This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed.
:param pulumi.Input['IBMBlockCSISpecControllerAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorArgs'] label_selector: A label query over a set of resources, in this case pods.
:param pulumi.Input[Sequence[pulumi.Input[str]]] namespaces: namespaces specifies which namespaces the labelSelector applies to (matches against); null or empty list means "this pod's namespace"<|endoftext|>
|
1a7fd32bfbac3e1d1c7b3da8ebc96670c998ac5294448293ae6cf957310d8ab3
|
@property
@pulumi.getter(name='topologyKey')
def topology_key(self) -> pulumi.Input[str]:
'\n This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed.\n '
return pulumi.get(self, 'topology_key')
|
This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
topology_key
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
@property
@pulumi.getter(name='topologyKey')
def topology_key(self) -> pulumi.Input[str]:
'\n \n '
return pulumi.get(self, 'topology_key')
|
@property
@pulumi.getter(name='topologyKey')
def topology_key(self) -> pulumi.Input[str]:
'\n \n '
return pulumi.get(self, 'topology_key')<|docstring|>This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed.<|endoftext|>
|
9b5abc4a8a428ed6e92265e705f7337d3ebe8ed9a39f5900907dcbc9c9b43a83
|
@property
@pulumi.getter(name='labelSelector')
def label_selector(self) -> Optional[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorArgs']]:
'\n A label query over a set of resources, in this case pods.\n '
return pulumi.get(self, 'label_selector')
|
A label query over a set of resources, in this case pods.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
label_selector
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
@property
@pulumi.getter(name='labelSelector')
def label_selector(self) -> Optional[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorArgs']]:
'\n \n '
return pulumi.get(self, 'label_selector')
|
@property
@pulumi.getter(name='labelSelector')
def label_selector(self) -> Optional[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorArgs']]:
'\n \n '
return pulumi.get(self, 'label_selector')<|docstring|>A label query over a set of resources, in this case pods.<|endoftext|>
|
cafaaebd0b2bde715d14eccb6c5349f21790206a44c76155207e11f20235f51a
|
@property
@pulumi.getter
def namespaces(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
'\n namespaces specifies which namespaces the labelSelector applies to (matches against); null or empty list means "this pod\'s namespace"\n '
return pulumi.get(self, 'namespaces')
|
namespaces specifies which namespaces the labelSelector applies to (matches against); null or empty list means "this pod's namespace"
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
namespaces
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
@property
@pulumi.getter
def namespaces(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
'\n namespaces specifies which namespaces the labelSelector applies to (matches against); null or empty list means "this pod\'s namespace"\n '
return pulumi.get(self, 'namespaces')
|
@property
@pulumi.getter
def namespaces(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
'\n namespaces specifies which namespaces the labelSelector applies to (matches against); null or empty list means "this pod\'s namespace"\n '
return pulumi.get(self, 'namespaces')<|docstring|>namespaces specifies which namespaces the labelSelector applies to (matches against); null or empty list means "this pod's namespace"<|endoftext|>
|
c433142ad42663bb370611bca8168ec1b61172143db90c1b6d4d49ec554c515c
|
def __init__(__self__, *, match_expressions: Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressionsArgs']]]]=None, match_labels: Optional[pulumi.Input[Mapping[(str, pulumi.Input[str])]]]=None):
'\n A label query over a set of resources, in this case pods.\n :param pulumi.Input[Sequence[pulumi.Input[\'IBMBlockCSISpecControllerAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressionsArgs\']]] match_expressions: matchExpressions is a list of label selector requirements. The requirements are ANDed.\n :param pulumi.Input[Mapping[str, pulumi.Input[str]]] match_labels: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.\n '
if (match_expressions is not None):
pulumi.set(__self__, 'match_expressions', match_expressions)
if (match_labels is not None):
pulumi.set(__self__, 'match_labels', match_labels)
|
A label query over a set of resources, in this case pods.
:param pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressionsArgs']]] match_expressions: matchExpressions is a list of label selector requirements. The requirements are ANDed.
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] match_labels: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
__init__
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
def __init__(__self__, *, match_expressions: Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressionsArgs']]]]=None, match_labels: Optional[pulumi.Input[Mapping[(str, pulumi.Input[str])]]]=None):
'\n A label query over a set of resources, in this case pods.\n :param pulumi.Input[Sequence[pulumi.Input[\'IBMBlockCSISpecControllerAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressionsArgs\']]] match_expressions: matchExpressions is a list of label selector requirements. The requirements are ANDed.\n :param pulumi.Input[Mapping[str, pulumi.Input[str]]] match_labels: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.\n '
if (match_expressions is not None):
pulumi.set(__self__, 'match_expressions', match_expressions)
if (match_labels is not None):
pulumi.set(__self__, 'match_labels', match_labels)
|
def __init__(__self__, *, match_expressions: Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressionsArgs']]]]=None, match_labels: Optional[pulumi.Input[Mapping[(str, pulumi.Input[str])]]]=None):
'\n A label query over a set of resources, in this case pods.\n :param pulumi.Input[Sequence[pulumi.Input[\'IBMBlockCSISpecControllerAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressionsArgs\']]] match_expressions: matchExpressions is a list of label selector requirements. The requirements are ANDed.\n :param pulumi.Input[Mapping[str, pulumi.Input[str]]] match_labels: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.\n '
if (match_expressions is not None):
pulumi.set(__self__, 'match_expressions', match_expressions)
if (match_labels is not None):
pulumi.set(__self__, 'match_labels', match_labels)<|docstring|>A label query over a set of resources, in this case pods.
:param pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressionsArgs']]] match_expressions: matchExpressions is a list of label selector requirements. The requirements are ANDed.
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] match_labels: matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.<|endoftext|>
|
d7422897c4858da3cde53c843cfa832527d7f9a905f3c12808be849e8105c427
|
@property
@pulumi.getter(name='matchExpressions')
def match_expressions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressionsArgs']]]]:
'\n matchExpressions is a list of label selector requirements. The requirements are ANDed.\n '
return pulumi.get(self, 'match_expressions')
|
matchExpressions is a list of label selector requirements. The requirements are ANDed.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
match_expressions
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
@property
@pulumi.getter(name='matchExpressions')
def match_expressions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressionsArgs']]]]:
'\n \n '
return pulumi.get(self, 'match_expressions')
|
@property
@pulumi.getter(name='matchExpressions')
def match_expressions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecControllerAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressionsArgs']]]]:
'\n \n '
return pulumi.get(self, 'match_expressions')<|docstring|>matchExpressions is a list of label selector requirements. The requirements are ANDed.<|endoftext|>
|
c8d28c22c7664eea6a56b076ef07546eb4ceb965de2e9c944999569f79409a76
|
@property
@pulumi.getter(name='matchLabels')
def match_labels(self) -> Optional[pulumi.Input[Mapping[(str, pulumi.Input[str])]]]:
'\n matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.\n '
return pulumi.get(self, 'match_labels')
|
matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
match_labels
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
@property
@pulumi.getter(name='matchLabels')
def match_labels(self) -> Optional[pulumi.Input[Mapping[(str, pulumi.Input[str])]]]:
'\n \n '
return pulumi.get(self, 'match_labels')
|
@property
@pulumi.getter(name='matchLabels')
def match_labels(self) -> Optional[pulumi.Input[Mapping[(str, pulumi.Input[str])]]]:
'\n \n '
return pulumi.get(self, 'match_labels')<|docstring|>matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.<|endoftext|>
|
c920819fc0b4fc3fe978eacb8fbb8d5f1500cc63d1fed6bf3274b88c2f2ce017
|
def __init__(__self__, *, key: pulumi.Input[str], operator: pulumi.Input[str], values: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None):
"\n A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.\n :param pulumi.Input[str] key: key is the label key that the selector applies to.\n :param pulumi.Input[str] operator: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] values: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.\n "
pulumi.set(__self__, 'key', key)
pulumi.set(__self__, 'operator', operator)
if (values is not None):
pulumi.set(__self__, 'values', values)
|
A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
:param pulumi.Input[str] key: key is the label key that the selector applies to.
:param pulumi.Input[str] operator: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.
:param pulumi.Input[Sequence[pulumi.Input[str]]] values: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
__init__
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
def __init__(__self__, *, key: pulumi.Input[str], operator: pulumi.Input[str], values: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None):
"\n A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.\n :param pulumi.Input[str] key: key is the label key that the selector applies to.\n :param pulumi.Input[str] operator: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] values: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.\n "
pulumi.set(__self__, 'key', key)
pulumi.set(__self__, 'operator', operator)
if (values is not None):
pulumi.set(__self__, 'values', values)
|
def __init__(__self__, *, key: pulumi.Input[str], operator: pulumi.Input[str], values: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None):
"\n A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.\n :param pulumi.Input[str] key: key is the label key that the selector applies to.\n :param pulumi.Input[str] operator: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] values: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.\n "
pulumi.set(__self__, 'key', key)
pulumi.set(__self__, 'operator', operator)
if (values is not None):
pulumi.set(__self__, 'values', values)<|docstring|>A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
:param pulumi.Input[str] key: key is the label key that the selector applies to.
:param pulumi.Input[str] operator: operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.
:param pulumi.Input[Sequence[pulumi.Input[str]]] values: values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.<|endoftext|>
|
873b01de6c7b4b390af7286e21dc936c9a738bde5f172c97010521d8ead34b94
|
@property
@pulumi.getter
def key(self) -> pulumi.Input[str]:
'\n key is the label key that the selector applies to.\n '
return pulumi.get(self, 'key')
|
key is the label key that the selector applies to.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
key
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
@property
@pulumi.getter
def key(self) -> pulumi.Input[str]:
'\n \n '
return pulumi.get(self, 'key')
|
@property
@pulumi.getter
def key(self) -> pulumi.Input[str]:
'\n \n '
return pulumi.get(self, 'key')<|docstring|>key is the label key that the selector applies to.<|endoftext|>
|
0c4e49e08176a0283877710e6179293ccac4fbb9a05b090e0d01b0bc406ff63f
|
@property
@pulumi.getter
def operator(self) -> pulumi.Input[str]:
"\n operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.\n "
return pulumi.get(self, 'operator')
|
operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
operator
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
@property
@pulumi.getter
def operator(self) -> pulumi.Input[str]:
"\n \n "
return pulumi.get(self, 'operator')
|
@property
@pulumi.getter
def operator(self) -> pulumi.Input[str]:
"\n \n "
return pulumi.get(self, 'operator')<|docstring|>operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.<|endoftext|>
|
8890282f9ab13c97f11910757bc10d16f9baa2504cd65573fd75ceafa57e1daf
|
@property
@pulumi.getter
def values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
'\n values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.\n '
return pulumi.get(self, 'values')
|
values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
values
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
@property
@pulumi.getter
def values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
'\n \n '
return pulumi.get(self, 'values')
|
@property
@pulumi.getter
def values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
'\n \n '
return pulumi.get(self, 'values')<|docstring|>values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.<|endoftext|>
|
792282a676c40c879cfb934a9fbf7817889dade407a6d6ec03318c357d63111d
|
def __init__(__self__, *, effect: Optional[pulumi.Input[str]]=None, key: Optional[pulumi.Input[str]]=None, operator: Optional[pulumi.Input[str]]=None, toleration_seconds: Optional[pulumi.Input[int]]=None, value: Optional[pulumi.Input[str]]=None):
"\n The pod this Toleration is attached to tolerates any taint that matches the triple <key,value,effect> using the matching operator <operator>.\n :param pulumi.Input[str] effect: Effect indicates the taint effect to match. Empty means match all taint effects. When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute.\n :param pulumi.Input[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.\n :param pulumi.Input[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 pod can tolerate all taints of a particular category.\n :param pulumi.Input[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.\n :param pulumi.Input[str] value: Value is the taint value the toleration matches to. If the operator is Exists, the value should be empty, otherwise just a regular string.\n "
if (effect is not None):
pulumi.set(__self__, 'effect', effect)
if (key is not None):
pulumi.set(__self__, 'key', key)
if (operator is not None):
pulumi.set(__self__, 'operator', operator)
if (toleration_seconds is not None):
pulumi.set(__self__, 'toleration_seconds', toleration_seconds)
if (value is not None):
pulumi.set(__self__, 'value', value)
|
The pod this Toleration is attached to tolerates any taint that matches the triple <key,value,effect> using the matching operator <operator>.
:param pulumi.Input[str] effect: Effect indicates the taint effect to match. Empty means match all taint effects. When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute.
:param pulumi.Input[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.
:param pulumi.Input[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 pod can tolerate all taints of a particular category.
:param pulumi.Input[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.
:param pulumi.Input[str] value: Value is the taint value the toleration matches to. If the operator is Exists, the value should be empty, otherwise just a regular string.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
__init__
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
def __init__(__self__, *, effect: Optional[pulumi.Input[str]]=None, key: Optional[pulumi.Input[str]]=None, operator: Optional[pulumi.Input[str]]=None, toleration_seconds: Optional[pulumi.Input[int]]=None, value: Optional[pulumi.Input[str]]=None):
"\n The pod this Toleration is attached to tolerates any taint that matches the triple <key,value,effect> using the matching operator <operator>.\n :param pulumi.Input[str] effect: Effect indicates the taint effect to match. Empty means match all taint effects. When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute.\n :param pulumi.Input[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.\n :param pulumi.Input[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 pod can tolerate all taints of a particular category.\n :param pulumi.Input[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.\n :param pulumi.Input[str] value: Value is the taint value the toleration matches to. If the operator is Exists, the value should be empty, otherwise just a regular string.\n "
if (effect is not None):
pulumi.set(__self__, 'effect', effect)
if (key is not None):
pulumi.set(__self__, 'key', key)
if (operator is not None):
pulumi.set(__self__, 'operator', operator)
if (toleration_seconds is not None):
pulumi.set(__self__, 'toleration_seconds', toleration_seconds)
if (value is not None):
pulumi.set(__self__, 'value', value)
|
def __init__(__self__, *, effect: Optional[pulumi.Input[str]]=None, key: Optional[pulumi.Input[str]]=None, operator: Optional[pulumi.Input[str]]=None, toleration_seconds: Optional[pulumi.Input[int]]=None, value: Optional[pulumi.Input[str]]=None):
"\n The pod this Toleration is attached to tolerates any taint that matches the triple <key,value,effect> using the matching operator <operator>.\n :param pulumi.Input[str] effect: Effect indicates the taint effect to match. Empty means match all taint effects. When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute.\n :param pulumi.Input[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.\n :param pulumi.Input[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 pod can tolerate all taints of a particular category.\n :param pulumi.Input[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.\n :param pulumi.Input[str] value: Value is the taint value the toleration matches to. If the operator is Exists, the value should be empty, otherwise just a regular string.\n "
if (effect is not None):
pulumi.set(__self__, 'effect', effect)
if (key is not None):
pulumi.set(__self__, 'key', key)
if (operator is not None):
pulumi.set(__self__, 'operator', operator)
if (toleration_seconds is not None):
pulumi.set(__self__, 'toleration_seconds', toleration_seconds)
if (value is not None):
pulumi.set(__self__, 'value', value)<|docstring|>The pod this Toleration is attached to tolerates any taint that matches the triple <key,value,effect> using the matching operator <operator>.
:param pulumi.Input[str] effect: Effect indicates the taint effect to match. Empty means match all taint effects. When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute.
:param pulumi.Input[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.
:param pulumi.Input[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 pod can tolerate all taints of a particular category.
:param pulumi.Input[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.
:param pulumi.Input[str] value: Value is the taint value the toleration matches to. If the operator is Exists, the value should be empty, otherwise just a regular string.<|endoftext|>
|
96948b7e3758758871da06382ec6963c7b7bad0427c696a8cbf58506fa7334ab
|
@property
@pulumi.getter
def effect(self) -> Optional[pulumi.Input[str]]:
'\n Effect indicates the taint effect to match. Empty means match all taint effects. When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute.\n '
return pulumi.get(self, 'effect')
|
Effect indicates the taint effect to match. Empty means match all taint effects. When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
effect
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
@property
@pulumi.getter
def effect(self) -> Optional[pulumi.Input[str]]:
'\n \n '
return pulumi.get(self, 'effect')
|
@property
@pulumi.getter
def effect(self) -> Optional[pulumi.Input[str]]:
'\n \n '
return pulumi.get(self, 'effect')<|docstring|>Effect indicates the taint effect to match. Empty means match all taint effects. When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute.<|endoftext|>
|
56a17d7ed8f5e92d7706a8ffd2c55cb6cc3a6609d8cce8250c66fcf5c3ab27bb
|
@property
@pulumi.getter
def key(self) -> Optional[pulumi.Input[str]]:
'\n 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.\n '
return pulumi.get(self, '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.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
key
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
@property
@pulumi.getter
def key(self) -> Optional[pulumi.Input[str]]:
'\n \n '
return pulumi.get(self, 'key')
|
@property
@pulumi.getter
def key(self) -> Optional[pulumi.Input[str]]:
'\n \n '
return pulumi.get(self, 'key')<|docstring|>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.<|endoftext|>
|
3c398ae7390efb94fe34d30e32ac9bcbaf5751730356d5b920a042bfe235940f
|
@property
@pulumi.getter
def operator(self) -> Optional[pulumi.Input[str]]:
"\n 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 pod can tolerate all taints of a particular category.\n "
return pulumi.get(self, '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 pod can tolerate all taints of a particular category.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
operator
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
@property
@pulumi.getter
def operator(self) -> Optional[pulumi.Input[str]]:
"\n \n "
return pulumi.get(self, 'operator')
|
@property
@pulumi.getter
def operator(self) -> Optional[pulumi.Input[str]]:
"\n \n "
return pulumi.get(self, 'operator')<|docstring|>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 pod can tolerate all taints of a particular category.<|endoftext|>
|
6904f5505ae78f512faf3af88f5928c30059929ce52f340f02f9ded6c50e1848
|
@property
@pulumi.getter(name='tolerationSeconds')
def toleration_seconds(self) -> Optional[pulumi.Input[int]]:
'\n 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.\n '
return pulumi.get(self, '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.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
toleration_seconds
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
@property
@pulumi.getter(name='tolerationSeconds')
def toleration_seconds(self) -> Optional[pulumi.Input[int]]:
'\n \n '
return pulumi.get(self, 'toleration_seconds')
|
@property
@pulumi.getter(name='tolerationSeconds')
def toleration_seconds(self) -> Optional[pulumi.Input[int]]:
'\n \n '
return pulumi.get(self, 'toleration_seconds')<|docstring|>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.<|endoftext|>
|
b0fe514b57d90ee8e06cda410198addb22eb038e54215645c2c74e93b62fc20e
|
@property
@pulumi.getter
def value(self) -> Optional[pulumi.Input[str]]:
'\n Value is the taint value the toleration matches to. If the operator is Exists, the value should be empty, otherwise just a regular string.\n '
return pulumi.get(self, 'value')
|
Value is the taint value the toleration matches to. If the operator is Exists, the value should be empty, otherwise just a regular string.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
value
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
@property
@pulumi.getter
def value(self) -> Optional[pulumi.Input[str]]:
'\n \n '
return pulumi.get(self, 'value')
|
@property
@pulumi.getter
def value(self) -> Optional[pulumi.Input[str]]:
'\n \n '
return pulumi.get(self, 'value')<|docstring|>Value is the taint value the toleration matches to. If the operator is Exists, the value should be empty, otherwise just a regular string.<|endoftext|>
|
888dcf50509c620268dd813b6c2060f9125f621cb3a0592e60e6c24cceb0a450
|
def __init__(__self__, *, repository: pulumi.Input[str], tag: pulumi.Input[str], affinity: Optional[pulumi.Input['IBMBlockCSISpecNodeAffinityArgs']]=None, image_pull_policy: Optional[pulumi.Input[str]]=None, tolerations: Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecNodeTolerationsArgs']]]]=None):
"\n IBMBlockCSINodeSpec defines the desired state of IBMBlockCSINode\n :param pulumi.Input['IBMBlockCSISpecNodeAffinityArgs'] affinity: Affinity is a group of affinity scheduling rules.\n :param pulumi.Input[str] image_pull_policy: PullPolicy describes a policy for if/when to pull a container image\n "
pulumi.set(__self__, 'repository', repository)
pulumi.set(__self__, 'tag', tag)
if (affinity is not None):
pulumi.set(__self__, 'affinity', affinity)
if (image_pull_policy is not None):
pulumi.set(__self__, 'image_pull_policy', image_pull_policy)
if (tolerations is not None):
pulumi.set(__self__, 'tolerations', tolerations)
|
IBMBlockCSINodeSpec defines the desired state of IBMBlockCSINode
:param pulumi.Input['IBMBlockCSISpecNodeAffinityArgs'] affinity: Affinity is a group of affinity scheduling rules.
:param pulumi.Input[str] image_pull_policy: PullPolicy describes a policy for if/when to pull a container image
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
__init__
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
def __init__(__self__, *, repository: pulumi.Input[str], tag: pulumi.Input[str], affinity: Optional[pulumi.Input['IBMBlockCSISpecNodeAffinityArgs']]=None, image_pull_policy: Optional[pulumi.Input[str]]=None, tolerations: Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecNodeTolerationsArgs']]]]=None):
"\n IBMBlockCSINodeSpec defines the desired state of IBMBlockCSINode\n :param pulumi.Input['IBMBlockCSISpecNodeAffinityArgs'] affinity: Affinity is a group of affinity scheduling rules.\n :param pulumi.Input[str] image_pull_policy: PullPolicy describes a policy for if/when to pull a container image\n "
pulumi.set(__self__, 'repository', repository)
pulumi.set(__self__, 'tag', tag)
if (affinity is not None):
pulumi.set(__self__, 'affinity', affinity)
if (image_pull_policy is not None):
pulumi.set(__self__, 'image_pull_policy', image_pull_policy)
if (tolerations is not None):
pulumi.set(__self__, 'tolerations', tolerations)
|
def __init__(__self__, *, repository: pulumi.Input[str], tag: pulumi.Input[str], affinity: Optional[pulumi.Input['IBMBlockCSISpecNodeAffinityArgs']]=None, image_pull_policy: Optional[pulumi.Input[str]]=None, tolerations: Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecNodeTolerationsArgs']]]]=None):
"\n IBMBlockCSINodeSpec defines the desired state of IBMBlockCSINode\n :param pulumi.Input['IBMBlockCSISpecNodeAffinityArgs'] affinity: Affinity is a group of affinity scheduling rules.\n :param pulumi.Input[str] image_pull_policy: PullPolicy describes a policy for if/when to pull a container image\n "
pulumi.set(__self__, 'repository', repository)
pulumi.set(__self__, 'tag', tag)
if (affinity is not None):
pulumi.set(__self__, 'affinity', affinity)
if (image_pull_policy is not None):
pulumi.set(__self__, 'image_pull_policy', image_pull_policy)
if (tolerations is not None):
pulumi.set(__self__, 'tolerations', tolerations)<|docstring|>IBMBlockCSINodeSpec defines the desired state of IBMBlockCSINode
:param pulumi.Input['IBMBlockCSISpecNodeAffinityArgs'] affinity: Affinity is a group of affinity scheduling rules.
:param pulumi.Input[str] image_pull_policy: PullPolicy describes a policy for if/when to pull a container image<|endoftext|>
|
d0abc8627c180595d7c3adf4bd4174fc97133e77e42a774b13447fbb3e955580
|
@property
@pulumi.getter
def affinity(self) -> Optional[pulumi.Input['IBMBlockCSISpecNodeAffinityArgs']]:
'\n Affinity is a group of affinity scheduling rules.\n '
return pulumi.get(self, 'affinity')
|
Affinity is a group of affinity scheduling rules.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
affinity
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
@property
@pulumi.getter
def affinity(self) -> Optional[pulumi.Input['IBMBlockCSISpecNodeAffinityArgs']]:
'\n \n '
return pulumi.get(self, 'affinity')
|
@property
@pulumi.getter
def affinity(self) -> Optional[pulumi.Input['IBMBlockCSISpecNodeAffinityArgs']]:
'\n \n '
return pulumi.get(self, 'affinity')<|docstring|>Affinity is a group of affinity scheduling rules.<|endoftext|>
|
eec3d8ad38fb7a2b6a5912c6049aff61bd330642ef6be829638386895c6d5dd6
|
@property
@pulumi.getter(name='imagePullPolicy')
def image_pull_policy(self) -> Optional[pulumi.Input[str]]:
'\n PullPolicy describes a policy for if/when to pull a container image\n '
return pulumi.get(self, 'image_pull_policy')
|
PullPolicy describes a policy for if/when to pull a container image
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
image_pull_policy
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
@property
@pulumi.getter(name='imagePullPolicy')
def image_pull_policy(self) -> Optional[pulumi.Input[str]]:
'\n \n '
return pulumi.get(self, 'image_pull_policy')
|
@property
@pulumi.getter(name='imagePullPolicy')
def image_pull_policy(self) -> Optional[pulumi.Input[str]]:
'\n \n '
return pulumi.get(self, 'image_pull_policy')<|docstring|>PullPolicy describes a policy for if/when to pull a container image<|endoftext|>
|
e36274cdcef0afd887466d6cfb4783ac8b9b61b5a3b7a0e875e7d107dd7dad53
|
def __init__(__self__, *, node_affinity: Optional[pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityArgs']]=None, pod_affinity: Optional[pulumi.Input['IBMBlockCSISpecNodeAffinityPodAffinityArgs']]=None, pod_anti_affinity: Optional[pulumi.Input['IBMBlockCSISpecNodeAffinityPodAntiAffinityArgs']]=None):
"\n Affinity is a group of affinity scheduling rules.\n :param pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityArgs'] node_affinity: Describes node affinity scheduling rules for the pod.\n :param pulumi.Input['IBMBlockCSISpecNodeAffinityPodAffinityArgs'] pod_affinity: Describes pod affinity scheduling rules (e.g. co-locate this pod in the same node, zone, etc. as some other pod(s)).\n :param pulumi.Input['IBMBlockCSISpecNodeAffinityPodAntiAffinityArgs'] pod_anti_affinity: Describes pod anti-affinity scheduling rules (e.g. avoid putting this pod in the same node, zone, etc. as some other pod(s)).\n "
if (node_affinity is not None):
pulumi.set(__self__, 'node_affinity', node_affinity)
if (pod_affinity is not None):
pulumi.set(__self__, 'pod_affinity', pod_affinity)
if (pod_anti_affinity is not None):
pulumi.set(__self__, 'pod_anti_affinity', pod_anti_affinity)
|
Affinity is a group of affinity scheduling rules.
:param pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityArgs'] node_affinity: Describes node affinity scheduling rules for the pod.
:param pulumi.Input['IBMBlockCSISpecNodeAffinityPodAffinityArgs'] pod_affinity: Describes pod affinity scheduling rules (e.g. co-locate this pod in the same node, zone, etc. as some other pod(s)).
:param pulumi.Input['IBMBlockCSISpecNodeAffinityPodAntiAffinityArgs'] pod_anti_affinity: Describes pod anti-affinity scheduling rules (e.g. avoid putting this pod in the same node, zone, etc. as some other pod(s)).
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
__init__
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
def __init__(__self__, *, node_affinity: Optional[pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityArgs']]=None, pod_affinity: Optional[pulumi.Input['IBMBlockCSISpecNodeAffinityPodAffinityArgs']]=None, pod_anti_affinity: Optional[pulumi.Input['IBMBlockCSISpecNodeAffinityPodAntiAffinityArgs']]=None):
"\n Affinity is a group of affinity scheduling rules.\n :param pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityArgs'] node_affinity: Describes node affinity scheduling rules for the pod.\n :param pulumi.Input['IBMBlockCSISpecNodeAffinityPodAffinityArgs'] pod_affinity: Describes pod affinity scheduling rules (e.g. co-locate this pod in the same node, zone, etc. as some other pod(s)).\n :param pulumi.Input['IBMBlockCSISpecNodeAffinityPodAntiAffinityArgs'] pod_anti_affinity: Describes pod anti-affinity scheduling rules (e.g. avoid putting this pod in the same node, zone, etc. as some other pod(s)).\n "
if (node_affinity is not None):
pulumi.set(__self__, 'node_affinity', node_affinity)
if (pod_affinity is not None):
pulumi.set(__self__, 'pod_affinity', pod_affinity)
if (pod_anti_affinity is not None):
pulumi.set(__self__, 'pod_anti_affinity', pod_anti_affinity)
|
def __init__(__self__, *, node_affinity: Optional[pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityArgs']]=None, pod_affinity: Optional[pulumi.Input['IBMBlockCSISpecNodeAffinityPodAffinityArgs']]=None, pod_anti_affinity: Optional[pulumi.Input['IBMBlockCSISpecNodeAffinityPodAntiAffinityArgs']]=None):
"\n Affinity is a group of affinity scheduling rules.\n :param pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityArgs'] node_affinity: Describes node affinity scheduling rules for the pod.\n :param pulumi.Input['IBMBlockCSISpecNodeAffinityPodAffinityArgs'] pod_affinity: Describes pod affinity scheduling rules (e.g. co-locate this pod in the same node, zone, etc. as some other pod(s)).\n :param pulumi.Input['IBMBlockCSISpecNodeAffinityPodAntiAffinityArgs'] pod_anti_affinity: Describes pod anti-affinity scheduling rules (e.g. avoid putting this pod in the same node, zone, etc. as some other pod(s)).\n "
if (node_affinity is not None):
pulumi.set(__self__, 'node_affinity', node_affinity)
if (pod_affinity is not None):
pulumi.set(__self__, 'pod_affinity', pod_affinity)
if (pod_anti_affinity is not None):
pulumi.set(__self__, 'pod_anti_affinity', pod_anti_affinity)<|docstring|>Affinity is a group of affinity scheduling rules.
:param pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityArgs'] node_affinity: Describes node affinity scheduling rules for the pod.
:param pulumi.Input['IBMBlockCSISpecNodeAffinityPodAffinityArgs'] pod_affinity: Describes pod affinity scheduling rules (e.g. co-locate this pod in the same node, zone, etc. as some other pod(s)).
:param pulumi.Input['IBMBlockCSISpecNodeAffinityPodAntiAffinityArgs'] pod_anti_affinity: Describes pod anti-affinity scheduling rules (e.g. avoid putting this pod in the same node, zone, etc. as some other pod(s)).<|endoftext|>
|
cafca5db1197af64ef582019106a10c7f8c9bc4d99854604c986a717f7d53ced
|
@property
@pulumi.getter(name='nodeAffinity')
def node_affinity(self) -> Optional[pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityArgs']]:
'\n Describes node affinity scheduling rules for the pod.\n '
return pulumi.get(self, 'node_affinity')
|
Describes node affinity scheduling rules for the pod.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
node_affinity
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
@property
@pulumi.getter(name='nodeAffinity')
def node_affinity(self) -> Optional[pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityArgs']]:
'\n \n '
return pulumi.get(self, 'node_affinity')
|
@property
@pulumi.getter(name='nodeAffinity')
def node_affinity(self) -> Optional[pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityArgs']]:
'\n \n '
return pulumi.get(self, 'node_affinity')<|docstring|>Describes node affinity scheduling rules for the pod.<|endoftext|>
|
4cb48634bcb333be95368fb6827e6672243e3658f635fecc2a61862d052588a5
|
@property
@pulumi.getter(name='podAffinity')
def pod_affinity(self) -> Optional[pulumi.Input['IBMBlockCSISpecNodeAffinityPodAffinityArgs']]:
'\n Describes pod affinity scheduling rules (e.g. co-locate this pod in the same node, zone, etc. as some other pod(s)).\n '
return pulumi.get(self, 'pod_affinity')
|
Describes pod affinity scheduling rules (e.g. co-locate this pod in the same node, zone, etc. as some other pod(s)).
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
pod_affinity
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
@property
@pulumi.getter(name='podAffinity')
def pod_affinity(self) -> Optional[pulumi.Input['IBMBlockCSISpecNodeAffinityPodAffinityArgs']]:
'\n \n '
return pulumi.get(self, 'pod_affinity')
|
@property
@pulumi.getter(name='podAffinity')
def pod_affinity(self) -> Optional[pulumi.Input['IBMBlockCSISpecNodeAffinityPodAffinityArgs']]:
'\n \n '
return pulumi.get(self, 'pod_affinity')<|docstring|>Describes pod affinity scheduling rules (e.g. co-locate this pod in the same node, zone, etc. as some other pod(s)).<|endoftext|>
|
22ba10748450d70de16c24680d3befd5faa1e40e89d02911d89dbee69db729f0
|
@property
@pulumi.getter(name='podAntiAffinity')
def pod_anti_affinity(self) -> Optional[pulumi.Input['IBMBlockCSISpecNodeAffinityPodAntiAffinityArgs']]:
'\n Describes pod anti-affinity scheduling rules (e.g. avoid putting this pod in the same node, zone, etc. as some other pod(s)).\n '
return pulumi.get(self, 'pod_anti_affinity')
|
Describes pod anti-affinity scheduling rules (e.g. avoid putting this pod in the same node, zone, etc. as some other pod(s)).
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
pod_anti_affinity
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
@property
@pulumi.getter(name='podAntiAffinity')
def pod_anti_affinity(self) -> Optional[pulumi.Input['IBMBlockCSISpecNodeAffinityPodAntiAffinityArgs']]:
'\n \n '
return pulumi.get(self, 'pod_anti_affinity')
|
@property
@pulumi.getter(name='podAntiAffinity')
def pod_anti_affinity(self) -> Optional[pulumi.Input['IBMBlockCSISpecNodeAffinityPodAntiAffinityArgs']]:
'\n \n '
return pulumi.get(self, 'pod_anti_affinity')<|docstring|>Describes pod anti-affinity scheduling rules (e.g. avoid putting this pod in the same node, zone, etc. as some other pod(s)).<|endoftext|>
|
cdc1c737af657c4bceaf1fd5a6cfc651b5eb537685e5ab6cb163abe26f888c9f
|
def __init__(__self__, *, preferred_during_scheduling_ignored_during_execution: Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionArgs']]]]=None, required_during_scheduling_ignored_during_execution: Optional[pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionArgs']]=None):
'\n Describes node affinity scheduling rules for the pod.\n :param pulumi.Input[Sequence[pulumi.Input[\'IBMBlockCSISpecNodeAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionArgs\']]] preferred_during_scheduling_ignored_during_execution: The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding "weight" to the sum if the node matches the corresponding matchExpressions; the node(s) with the highest sum are the most preferred.\n :param pulumi.Input[\'IBMBlockCSISpecNodeAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionArgs\'] required_during_scheduling_ignored_during_execution: If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to an update), the system may or may not try to eventually evict the pod from its node.\n '
if (preferred_during_scheduling_ignored_during_execution is not None):
pulumi.set(__self__, 'preferred_during_scheduling_ignored_during_execution', preferred_during_scheduling_ignored_during_execution)
if (required_during_scheduling_ignored_during_execution is not None):
pulumi.set(__self__, 'required_during_scheduling_ignored_during_execution', required_during_scheduling_ignored_during_execution)
|
Describes node affinity scheduling rules for the pod.
:param pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionArgs']]] preferred_during_scheduling_ignored_during_execution: The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding "weight" to the sum if the node matches the corresponding matchExpressions; the node(s) with the highest sum are the most preferred.
:param pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionArgs'] required_during_scheduling_ignored_during_execution: If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to an update), the system may or may not try to eventually evict the pod from its node.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
__init__
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
def __init__(__self__, *, preferred_during_scheduling_ignored_during_execution: Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionArgs']]]]=None, required_during_scheduling_ignored_during_execution: Optional[pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionArgs']]=None):
'\n Describes node affinity scheduling rules for the pod.\n :param pulumi.Input[Sequence[pulumi.Input[\'IBMBlockCSISpecNodeAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionArgs\']]] preferred_during_scheduling_ignored_during_execution: The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding "weight" to the sum if the node matches the corresponding matchExpressions; the node(s) with the highest sum are the most preferred.\n :param pulumi.Input[\'IBMBlockCSISpecNodeAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionArgs\'] required_during_scheduling_ignored_during_execution: If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to an update), the system may or may not try to eventually evict the pod from its node.\n '
if (preferred_during_scheduling_ignored_during_execution is not None):
pulumi.set(__self__, 'preferred_during_scheduling_ignored_during_execution', preferred_during_scheduling_ignored_during_execution)
if (required_during_scheduling_ignored_during_execution is not None):
pulumi.set(__self__, 'required_during_scheduling_ignored_during_execution', required_during_scheduling_ignored_during_execution)
|
def __init__(__self__, *, preferred_during_scheduling_ignored_during_execution: Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionArgs']]]]=None, required_during_scheduling_ignored_during_execution: Optional[pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionArgs']]=None):
'\n Describes node affinity scheduling rules for the pod.\n :param pulumi.Input[Sequence[pulumi.Input[\'IBMBlockCSISpecNodeAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionArgs\']]] preferred_during_scheduling_ignored_during_execution: The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding "weight" to the sum if the node matches the corresponding matchExpressions; the node(s) with the highest sum are the most preferred.\n :param pulumi.Input[\'IBMBlockCSISpecNodeAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionArgs\'] required_during_scheduling_ignored_during_execution: If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to an update), the system may or may not try to eventually evict the pod from its node.\n '
if (preferred_during_scheduling_ignored_during_execution is not None):
pulumi.set(__self__, 'preferred_during_scheduling_ignored_during_execution', preferred_during_scheduling_ignored_during_execution)
if (required_during_scheduling_ignored_during_execution is not None):
pulumi.set(__self__, 'required_during_scheduling_ignored_during_execution', required_during_scheduling_ignored_during_execution)<|docstring|>Describes node affinity scheduling rules for the pod.
:param pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionArgs']]] preferred_during_scheduling_ignored_during_execution: The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding "weight" to the sum if the node matches the corresponding matchExpressions; the node(s) with the highest sum are the most preferred.
:param pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionArgs'] required_during_scheduling_ignored_during_execution: If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to an update), the system may or may not try to eventually evict the pod from its node.<|endoftext|>
|
6f943787b2158b306ffa55ca76eb64f5eefd9494956c73a0837766e6dd7cf094
|
@property
@pulumi.getter(name='preferredDuringSchedulingIgnoredDuringExecution')
def preferred_during_scheduling_ignored_during_execution(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionArgs']]]]:
'\n The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding "weight" to the sum if the node matches the corresponding matchExpressions; the node(s) with the highest sum are the most preferred.\n '
return pulumi.get(self, 'preferred_during_scheduling_ignored_during_execution')
|
The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding "weight" to the sum if the node matches the corresponding matchExpressions; the node(s) with the highest sum are the most preferred.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
preferred_during_scheduling_ignored_during_execution
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
@property
@pulumi.getter(name='preferredDuringSchedulingIgnoredDuringExecution')
def preferred_during_scheduling_ignored_during_execution(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionArgs']]]]:
'\n \n '
return pulumi.get(self, 'preferred_during_scheduling_ignored_during_execution')
|
@property
@pulumi.getter(name='preferredDuringSchedulingIgnoredDuringExecution')
def preferred_during_scheduling_ignored_during_execution(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionArgs']]]]:
'\n \n '
return pulumi.get(self, 'preferred_during_scheduling_ignored_during_execution')<|docstring|>The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions. The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding "weight" to the sum if the node matches the corresponding matchExpressions; the node(s) with the highest sum are the most preferred.<|endoftext|>
|
c8ec39ce7274447454e4d4eef4e23e12956ef3ae5dcbd2e0c606537d079c3f85
|
@property
@pulumi.getter(name='requiredDuringSchedulingIgnoredDuringExecution')
def required_during_scheduling_ignored_during_execution(self) -> Optional[pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionArgs']]:
'\n If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to an update), the system may or may not try to eventually evict the pod from its node.\n '
return pulumi.get(self, 'required_during_scheduling_ignored_during_execution')
|
If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to an update), the system may or may not try to eventually evict the pod from its node.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
required_during_scheduling_ignored_during_execution
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
@property
@pulumi.getter(name='requiredDuringSchedulingIgnoredDuringExecution')
def required_during_scheduling_ignored_during_execution(self) -> Optional[pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionArgs']]:
'\n \n '
return pulumi.get(self, 'required_during_scheduling_ignored_during_execution')
|
@property
@pulumi.getter(name='requiredDuringSchedulingIgnoredDuringExecution')
def required_during_scheduling_ignored_during_execution(self) -> Optional[pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionArgs']]:
'\n \n '
return pulumi.get(self, 'required_during_scheduling_ignored_during_execution')<|docstring|>If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to an update), the system may or may not try to eventually evict the pod from its node.<|endoftext|>
|
7b42445478dcf2f075e214b7bced574c63d2d911047eff493e3b12bc5a7aa658
|
def __init__(__self__, *, preference: pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceArgs'], weight: pulumi.Input[int]):
"\n An empty preferred scheduling term matches all objects with implicit weight 0 (i.e. it's a no-op). A null preferred scheduling term matches no objects (i.e. is also a no-op).\n :param pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceArgs'] preference: A node selector term, associated with the corresponding weight.\n :param pulumi.Input[int] weight: Weight associated with matching the corresponding nodeSelectorTerm, in the range 1-100.\n "
pulumi.set(__self__, 'preference', preference)
pulumi.set(__self__, 'weight', weight)
|
An empty preferred scheduling term matches all objects with implicit weight 0 (i.e. it's a no-op). A null preferred scheduling term matches no objects (i.e. is also a no-op).
:param pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceArgs'] preference: A node selector term, associated with the corresponding weight.
:param pulumi.Input[int] weight: Weight associated with matching the corresponding nodeSelectorTerm, in the range 1-100.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
__init__
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
def __init__(__self__, *, preference: pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceArgs'], weight: pulumi.Input[int]):
"\n An empty preferred scheduling term matches all objects with implicit weight 0 (i.e. it's a no-op). A null preferred scheduling term matches no objects (i.e. is also a no-op).\n :param pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceArgs'] preference: A node selector term, associated with the corresponding weight.\n :param pulumi.Input[int] weight: Weight associated with matching the corresponding nodeSelectorTerm, in the range 1-100.\n "
pulumi.set(__self__, 'preference', preference)
pulumi.set(__self__, 'weight', weight)
|
def __init__(__self__, *, preference: pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceArgs'], weight: pulumi.Input[int]):
"\n An empty preferred scheduling term matches all objects with implicit weight 0 (i.e. it's a no-op). A null preferred scheduling term matches no objects (i.e. is also a no-op).\n :param pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceArgs'] preference: A node selector term, associated with the corresponding weight.\n :param pulumi.Input[int] weight: Weight associated with matching the corresponding nodeSelectorTerm, in the range 1-100.\n "
pulumi.set(__self__, 'preference', preference)
pulumi.set(__self__, 'weight', weight)<|docstring|>An empty preferred scheduling term matches all objects with implicit weight 0 (i.e. it's a no-op). A null preferred scheduling term matches no objects (i.e. is also a no-op).
:param pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceArgs'] preference: A node selector term, associated with the corresponding weight.
:param pulumi.Input[int] weight: Weight associated with matching the corresponding nodeSelectorTerm, in the range 1-100.<|endoftext|>
|
96a583cbcb83828870ba28c4e69a4927f52d3d11d82f0aa68d9a100ec0f65ede
|
@property
@pulumi.getter
def preference(self) -> pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceArgs']:
'\n A node selector term, associated with the corresponding weight.\n '
return pulumi.get(self, 'preference')
|
A node selector term, associated with the corresponding weight.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
preference
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
@property
@pulumi.getter
def preference(self) -> pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceArgs']:
'\n \n '
return pulumi.get(self, 'preference')
|
@property
@pulumi.getter
def preference(self) -> pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceArgs']:
'\n \n '
return pulumi.get(self, 'preference')<|docstring|>A node selector term, associated with the corresponding weight.<|endoftext|>
|
68c1b973384e8ecfa9b5c47d4dc3186fa5244e1bb3a3957577ed52cc37586925
|
@property
@pulumi.getter
def weight(self) -> pulumi.Input[int]:
'\n Weight associated with matching the corresponding nodeSelectorTerm, in the range 1-100.\n '
return pulumi.get(self, 'weight')
|
Weight associated with matching the corresponding nodeSelectorTerm, in the range 1-100.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
weight
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
@property
@pulumi.getter
def weight(self) -> pulumi.Input[int]:
'\n \n '
return pulumi.get(self, 'weight')
|
@property
@pulumi.getter
def weight(self) -> pulumi.Input[int]:
'\n \n '
return pulumi.get(self, 'weight')<|docstring|>Weight associated with matching the corresponding nodeSelectorTerm, in the range 1-100.<|endoftext|>
|
f03a2de46007b044a4e09e9741842367a9e178a8adbf594f6ab20da5139332eb
|
def __init__(__self__, *, match_expressions: Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchExpressionsArgs']]]]=None, match_fields: Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchFieldsArgs']]]]=None):
"\n A node selector term, associated with the corresponding weight.\n :param pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchExpressionsArgs']]] match_expressions: A list of node selector requirements by node's labels.\n :param pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchFieldsArgs']]] match_fields: A list of node selector requirements by node's fields.\n "
if (match_expressions is not None):
pulumi.set(__self__, 'match_expressions', match_expressions)
if (match_fields is not None):
pulumi.set(__self__, 'match_fields', match_fields)
|
A node selector term, associated with the corresponding weight.
:param pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchExpressionsArgs']]] match_expressions: A list of node selector requirements by node's labels.
:param pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchFieldsArgs']]] match_fields: A list of node selector requirements by node's fields.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
__init__
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
def __init__(__self__, *, match_expressions: Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchExpressionsArgs']]]]=None, match_fields: Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchFieldsArgs']]]]=None):
"\n A node selector term, associated with the corresponding weight.\n :param pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchExpressionsArgs']]] match_expressions: A list of node selector requirements by node's labels.\n :param pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchFieldsArgs']]] match_fields: A list of node selector requirements by node's fields.\n "
if (match_expressions is not None):
pulumi.set(__self__, 'match_expressions', match_expressions)
if (match_fields is not None):
pulumi.set(__self__, 'match_fields', match_fields)
|
def __init__(__self__, *, match_expressions: Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchExpressionsArgs']]]]=None, match_fields: Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchFieldsArgs']]]]=None):
"\n A node selector term, associated with the corresponding weight.\n :param pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchExpressionsArgs']]] match_expressions: A list of node selector requirements by node's labels.\n :param pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchFieldsArgs']]] match_fields: A list of node selector requirements by node's fields.\n "
if (match_expressions is not None):
pulumi.set(__self__, 'match_expressions', match_expressions)
if (match_fields is not None):
pulumi.set(__self__, 'match_fields', match_fields)<|docstring|>A node selector term, associated with the corresponding weight.
:param pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchExpressionsArgs']]] match_expressions: A list of node selector requirements by node's labels.
:param pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchFieldsArgs']]] match_fields: A list of node selector requirements by node's fields.<|endoftext|>
|
69821823783ac841468933ce65e7cf40abdb59b5ec7b771540642a4300e02f1b
|
@property
@pulumi.getter(name='matchExpressions')
def match_expressions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchExpressionsArgs']]]]:
"\n A list of node selector requirements by node's labels.\n "
return pulumi.get(self, 'match_expressions')
|
A list of node selector requirements by node's labels.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
match_expressions
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
@property
@pulumi.getter(name='matchExpressions')
def match_expressions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchExpressionsArgs']]]]:
"\n \n "
return pulumi.get(self, 'match_expressions')
|
@property
@pulumi.getter(name='matchExpressions')
def match_expressions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchExpressionsArgs']]]]:
"\n \n "
return pulumi.get(self, 'match_expressions')<|docstring|>A list of node selector requirements by node's labels.<|endoftext|>
|
2c81ab883b102c1d373040b7af46c07f92758007df3c358dd0567ea2f9d4c853
|
@property
@pulumi.getter(name='matchFields')
def match_fields(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchFieldsArgs']]]]:
"\n A list of node selector requirements by node's fields.\n "
return pulumi.get(self, 'match_fields')
|
A list of node selector requirements by node's fields.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
match_fields
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
@property
@pulumi.getter(name='matchFields')
def match_fields(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchFieldsArgs']]]]:
"\n \n "
return pulumi.get(self, 'match_fields')
|
@property
@pulumi.getter(name='matchFields')
def match_fields(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchFieldsArgs']]]]:
"\n \n "
return pulumi.get(self, 'match_fields')<|docstring|>A list of node selector requirements by node's fields.<|endoftext|>
|
bf5e44d0e580083b08c3f5d19b06e03c46a981848dd902f10b7e1e615be95e67
|
def __init__(__self__, *, key: pulumi.Input[str], operator: pulumi.Input[str], values: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None):
"\n A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.\n :param pulumi.Input[str] key: The label key that the selector applies to.\n :param pulumi.Input[str] operator: Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] values: An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.\n "
pulumi.set(__self__, 'key', key)
pulumi.set(__self__, 'operator', operator)
if (values is not None):
pulumi.set(__self__, 'values', values)
|
A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
:param pulumi.Input[str] key: The label key that the selector applies to.
:param pulumi.Input[str] operator: Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.
:param pulumi.Input[Sequence[pulumi.Input[str]]] values: An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
__init__
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
def __init__(__self__, *, key: pulumi.Input[str], operator: pulumi.Input[str], values: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None):
"\n A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.\n :param pulumi.Input[str] key: The label key that the selector applies to.\n :param pulumi.Input[str] operator: Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] values: An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.\n "
pulumi.set(__self__, 'key', key)
pulumi.set(__self__, 'operator', operator)
if (values is not None):
pulumi.set(__self__, 'values', values)
|
def __init__(__self__, *, key: pulumi.Input[str], operator: pulumi.Input[str], values: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None):
"\n A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.\n :param pulumi.Input[str] key: The label key that the selector applies to.\n :param pulumi.Input[str] operator: Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] values: An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.\n "
pulumi.set(__self__, 'key', key)
pulumi.set(__self__, 'operator', operator)
if (values is not None):
pulumi.set(__self__, 'values', values)<|docstring|>A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
:param pulumi.Input[str] key: The label key that the selector applies to.
:param pulumi.Input[str] operator: Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.
:param pulumi.Input[Sequence[pulumi.Input[str]]] values: An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.<|endoftext|>
|
6cf7c8938f7ceca38c2736fba43ed8ef4a46a14b2f0c1c1a3e2847900d0ba1cc
|
@property
@pulumi.getter
def key(self) -> pulumi.Input[str]:
'\n The label key that the selector applies to.\n '
return pulumi.get(self, 'key')
|
The label key that the selector applies to.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
key
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
@property
@pulumi.getter
def key(self) -> pulumi.Input[str]:
'\n \n '
return pulumi.get(self, 'key')
|
@property
@pulumi.getter
def key(self) -> pulumi.Input[str]:
'\n \n '
return pulumi.get(self, 'key')<|docstring|>The label key that the selector applies to.<|endoftext|>
|
026834ef706ec81b0dac6449994d81a644e4e6273652b199546c01310ae542ba
|
@property
@pulumi.getter
def operator(self) -> pulumi.Input[str]:
"\n Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.\n "
return pulumi.get(self, 'operator')
|
Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
operator
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
@property
@pulumi.getter
def operator(self) -> pulumi.Input[str]:
"\n \n "
return pulumi.get(self, 'operator')
|
@property
@pulumi.getter
def operator(self) -> pulumi.Input[str]:
"\n \n "
return pulumi.get(self, 'operator')<|docstring|>Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.<|endoftext|>
|
1156c9e0af0cbb14c25f97914f22f3802e172355689d41403da88d3ce78227b5
|
@property
@pulumi.getter
def values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
'\n An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.\n '
return pulumi.get(self, 'values')
|
An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
values
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
@property
@pulumi.getter
def values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
'\n \n '
return pulumi.get(self, 'values')
|
@property
@pulumi.getter
def values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
'\n \n '
return pulumi.get(self, 'values')<|docstring|>An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.<|endoftext|>
|
bf5e44d0e580083b08c3f5d19b06e03c46a981848dd902f10b7e1e615be95e67
|
def __init__(__self__, *, key: pulumi.Input[str], operator: pulumi.Input[str], values: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None):
"\n A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.\n :param pulumi.Input[str] key: The label key that the selector applies to.\n :param pulumi.Input[str] operator: Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] values: An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.\n "
pulumi.set(__self__, 'key', key)
pulumi.set(__self__, 'operator', operator)
if (values is not None):
pulumi.set(__self__, 'values', values)
|
A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
:param pulumi.Input[str] key: The label key that the selector applies to.
:param pulumi.Input[str] operator: Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.
:param pulumi.Input[Sequence[pulumi.Input[str]]] values: An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
__init__
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
def __init__(__self__, *, key: pulumi.Input[str], operator: pulumi.Input[str], values: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None):
"\n A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.\n :param pulumi.Input[str] key: The label key that the selector applies to.\n :param pulumi.Input[str] operator: Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] values: An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.\n "
pulumi.set(__self__, 'key', key)
pulumi.set(__self__, 'operator', operator)
if (values is not None):
pulumi.set(__self__, 'values', values)
|
def __init__(__self__, *, key: pulumi.Input[str], operator: pulumi.Input[str], values: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None):
"\n A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.\n :param pulumi.Input[str] key: The label key that the selector applies to.\n :param pulumi.Input[str] operator: Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] values: An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.\n "
pulumi.set(__self__, 'key', key)
pulumi.set(__self__, 'operator', operator)
if (values is not None):
pulumi.set(__self__, 'values', values)<|docstring|>A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
:param pulumi.Input[str] key: The label key that the selector applies to.
:param pulumi.Input[str] operator: Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.
:param pulumi.Input[Sequence[pulumi.Input[str]]] values: An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.<|endoftext|>
|
6cf7c8938f7ceca38c2736fba43ed8ef4a46a14b2f0c1c1a3e2847900d0ba1cc
|
@property
@pulumi.getter
def key(self) -> pulumi.Input[str]:
'\n The label key that the selector applies to.\n '
return pulumi.get(self, 'key')
|
The label key that the selector applies to.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
key
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
@property
@pulumi.getter
def key(self) -> pulumi.Input[str]:
'\n \n '
return pulumi.get(self, 'key')
|
@property
@pulumi.getter
def key(self) -> pulumi.Input[str]:
'\n \n '
return pulumi.get(self, 'key')<|docstring|>The label key that the selector applies to.<|endoftext|>
|
026834ef706ec81b0dac6449994d81a644e4e6273652b199546c01310ae542ba
|
@property
@pulumi.getter
def operator(self) -> pulumi.Input[str]:
"\n Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.\n "
return pulumi.get(self, 'operator')
|
Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
operator
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
@property
@pulumi.getter
def operator(self) -> pulumi.Input[str]:
"\n \n "
return pulumi.get(self, 'operator')
|
@property
@pulumi.getter
def operator(self) -> pulumi.Input[str]:
"\n \n "
return pulumi.get(self, 'operator')<|docstring|>Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.<|endoftext|>
|
1156c9e0af0cbb14c25f97914f22f3802e172355689d41403da88d3ce78227b5
|
@property
@pulumi.getter
def values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
'\n An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.\n '
return pulumi.get(self, 'values')
|
An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
values
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
@property
@pulumi.getter
def values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
'\n \n '
return pulumi.get(self, 'values')
|
@property
@pulumi.getter
def values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
'\n \n '
return pulumi.get(self, 'values')<|docstring|>An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.<|endoftext|>
|
df5acc393fe2e48bbed7bd5f9933e9285da1fcef01639f5f7153f36357c21695
|
def __init__(__self__, *, node_selector_terms: pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsArgs']]]):
"\n If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to an update), the system may or may not try to eventually evict the pod from its node.\n :param pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsArgs']]] node_selector_terms: Required. A list of node selector terms. The terms are ORed.\n "
pulumi.set(__self__, 'node_selector_terms', node_selector_terms)
|
If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to an update), the system may or may not try to eventually evict the pod from its node.
:param pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsArgs']]] node_selector_terms: Required. A list of node selector terms. The terms are ORed.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
__init__
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
def __init__(__self__, *, node_selector_terms: pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsArgs']]]):
"\n If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to an update), the system may or may not try to eventually evict the pod from its node.\n :param pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsArgs']]] node_selector_terms: Required. A list of node selector terms. The terms are ORed.\n "
pulumi.set(__self__, 'node_selector_terms', node_selector_terms)
|
def __init__(__self__, *, node_selector_terms: pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsArgs']]]):
"\n If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to an update), the system may or may not try to eventually evict the pod from its node.\n :param pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsArgs']]] node_selector_terms: Required. A list of node selector terms. The terms are ORed.\n "
pulumi.set(__self__, 'node_selector_terms', node_selector_terms)<|docstring|>If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node. If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to an update), the system may or may not try to eventually evict the pod from its node.
:param pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsArgs']]] node_selector_terms: Required. A list of node selector terms. The terms are ORed.<|endoftext|>
|
1a84bcb1203ee292bcdffb201081c45c8a7b45effd60da160d24a671c4dce954
|
@property
@pulumi.getter(name='nodeSelectorTerms')
def node_selector_terms(self) -> pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsArgs']]]:
'\n Required. A list of node selector terms. The terms are ORed.\n '
return pulumi.get(self, 'node_selector_terms')
|
Required. A list of node selector terms. The terms are ORed.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
node_selector_terms
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
@property
@pulumi.getter(name='nodeSelectorTerms')
def node_selector_terms(self) -> pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsArgs']]]:
'\n \n '
return pulumi.get(self, 'node_selector_terms')
|
@property
@pulumi.getter(name='nodeSelectorTerms')
def node_selector_terms(self) -> pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsArgs']]]:
'\n \n '
return pulumi.get(self, 'node_selector_terms')<|docstring|>Required. A list of node selector terms. The terms are ORed.<|endoftext|>
|
6f411497d91d24ee742ca3c04a63e073d739d85a7f24589bcb26185e3a609554
|
def __init__(__self__, *, match_expressions: Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchExpressionsArgs']]]]=None, match_fields: Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchFieldsArgs']]]]=None):
"\n A null or empty node selector term matches no objects. The requirements of them are ANDed. The TopologySelectorTerm type implements a subset of the NodeSelectorTerm.\n :param pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchExpressionsArgs']]] match_expressions: A list of node selector requirements by node's labels.\n :param pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchFieldsArgs']]] match_fields: A list of node selector requirements by node's fields.\n "
if (match_expressions is not None):
pulumi.set(__self__, 'match_expressions', match_expressions)
if (match_fields is not None):
pulumi.set(__self__, 'match_fields', match_fields)
|
A null or empty node selector term matches no objects. The requirements of them are ANDed. The TopologySelectorTerm type implements a subset of the NodeSelectorTerm.
:param pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchExpressionsArgs']]] match_expressions: A list of node selector requirements by node's labels.
:param pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchFieldsArgs']]] match_fields: A list of node selector requirements by node's fields.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
__init__
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
def __init__(__self__, *, match_expressions: Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchExpressionsArgs']]]]=None, match_fields: Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchFieldsArgs']]]]=None):
"\n A null or empty node selector term matches no objects. The requirements of them are ANDed. The TopologySelectorTerm type implements a subset of the NodeSelectorTerm.\n :param pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchExpressionsArgs']]] match_expressions: A list of node selector requirements by node's labels.\n :param pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchFieldsArgs']]] match_fields: A list of node selector requirements by node's fields.\n "
if (match_expressions is not None):
pulumi.set(__self__, 'match_expressions', match_expressions)
if (match_fields is not None):
pulumi.set(__self__, 'match_fields', match_fields)
|
def __init__(__self__, *, match_expressions: Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchExpressionsArgs']]]]=None, match_fields: Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchFieldsArgs']]]]=None):
"\n A null or empty node selector term matches no objects. The requirements of them are ANDed. The TopologySelectorTerm type implements a subset of the NodeSelectorTerm.\n :param pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchExpressionsArgs']]] match_expressions: A list of node selector requirements by node's labels.\n :param pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchFieldsArgs']]] match_fields: A list of node selector requirements by node's fields.\n "
if (match_expressions is not None):
pulumi.set(__self__, 'match_expressions', match_expressions)
if (match_fields is not None):
pulumi.set(__self__, 'match_fields', match_fields)<|docstring|>A null or empty node selector term matches no objects. The requirements of them are ANDed. The TopologySelectorTerm type implements a subset of the NodeSelectorTerm.
:param pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchExpressionsArgs']]] match_expressions: A list of node selector requirements by node's labels.
:param pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchFieldsArgs']]] match_fields: A list of node selector requirements by node's fields.<|endoftext|>
|
a468abcf84c5696d16deb6da5f378db0877c91326b2a24d42499e96bd4e0a9a2
|
@property
@pulumi.getter(name='matchExpressions')
def match_expressions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchExpressionsArgs']]]]:
"\n A list of node selector requirements by node's labels.\n "
return pulumi.get(self, 'match_expressions')
|
A list of node selector requirements by node's labels.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
match_expressions
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
@property
@pulumi.getter(name='matchExpressions')
def match_expressions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchExpressionsArgs']]]]:
"\n \n "
return pulumi.get(self, 'match_expressions')
|
@property
@pulumi.getter(name='matchExpressions')
def match_expressions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchExpressionsArgs']]]]:
"\n \n "
return pulumi.get(self, 'match_expressions')<|docstring|>A list of node selector requirements by node's labels.<|endoftext|>
|
4de6052e49eb4fef13e28e209b773439516253e7bd26eb5b25960e2002171942
|
@property
@pulumi.getter(name='matchFields')
def match_fields(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchFieldsArgs']]]]:
"\n A list of node selector requirements by node's fields.\n "
return pulumi.get(self, 'match_fields')
|
A list of node selector requirements by node's fields.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
match_fields
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
@property
@pulumi.getter(name='matchFields')
def match_fields(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchFieldsArgs']]]]:
"\n \n "
return pulumi.get(self, 'match_fields')
|
@property
@pulumi.getter(name='matchFields')
def match_fields(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['IBMBlockCSISpecNodeAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchFieldsArgs']]]]:
"\n \n "
return pulumi.get(self, 'match_fields')<|docstring|>A list of node selector requirements by node's fields.<|endoftext|>
|
bf5e44d0e580083b08c3f5d19b06e03c46a981848dd902f10b7e1e615be95e67
|
def __init__(__self__, *, key: pulumi.Input[str], operator: pulumi.Input[str], values: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None):
"\n A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.\n :param pulumi.Input[str] key: The label key that the selector applies to.\n :param pulumi.Input[str] operator: Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] values: An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.\n "
pulumi.set(__self__, 'key', key)
pulumi.set(__self__, 'operator', operator)
if (values is not None):
pulumi.set(__self__, 'values', values)
|
A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
:param pulumi.Input[str] key: The label key that the selector applies to.
:param pulumi.Input[str] operator: Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.
:param pulumi.Input[Sequence[pulumi.Input[str]]] values: An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
__init__
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
def __init__(__self__, *, key: pulumi.Input[str], operator: pulumi.Input[str], values: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None):
"\n A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.\n :param pulumi.Input[str] key: The label key that the selector applies to.\n :param pulumi.Input[str] operator: Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] values: An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.\n "
pulumi.set(__self__, 'key', key)
pulumi.set(__self__, 'operator', operator)
if (values is not None):
pulumi.set(__self__, 'values', values)
|
def __init__(__self__, *, key: pulumi.Input[str], operator: pulumi.Input[str], values: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None):
"\n A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.\n :param pulumi.Input[str] key: The label key that the selector applies to.\n :param pulumi.Input[str] operator: Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] values: An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.\n "
pulumi.set(__self__, 'key', key)
pulumi.set(__self__, 'operator', operator)
if (values is not None):
pulumi.set(__self__, 'values', values)<|docstring|>A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
:param pulumi.Input[str] key: The label key that the selector applies to.
:param pulumi.Input[str] operator: Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.
:param pulumi.Input[Sequence[pulumi.Input[str]]] values: An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.<|endoftext|>
|
6cf7c8938f7ceca38c2736fba43ed8ef4a46a14b2f0c1c1a3e2847900d0ba1cc
|
@property
@pulumi.getter
def key(self) -> pulumi.Input[str]:
'\n The label key that the selector applies to.\n '
return pulumi.get(self, 'key')
|
The label key that the selector applies to.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
key
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
@property
@pulumi.getter
def key(self) -> pulumi.Input[str]:
'\n \n '
return pulumi.get(self, 'key')
|
@property
@pulumi.getter
def key(self) -> pulumi.Input[str]:
'\n \n '
return pulumi.get(self, 'key')<|docstring|>The label key that the selector applies to.<|endoftext|>
|
026834ef706ec81b0dac6449994d81a644e4e6273652b199546c01310ae542ba
|
@property
@pulumi.getter
def operator(self) -> pulumi.Input[str]:
"\n Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.\n "
return pulumi.get(self, 'operator')
|
Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
operator
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
@property
@pulumi.getter
def operator(self) -> pulumi.Input[str]:
"\n \n "
return pulumi.get(self, 'operator')
|
@property
@pulumi.getter
def operator(self) -> pulumi.Input[str]:
"\n \n "
return pulumi.get(self, 'operator')<|docstring|>Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.<|endoftext|>
|
1156c9e0af0cbb14c25f97914f22f3802e172355689d41403da88d3ce78227b5
|
@property
@pulumi.getter
def values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
'\n An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.\n '
return pulumi.get(self, 'values')
|
An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
values
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
@property
@pulumi.getter
def values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
'\n \n '
return pulumi.get(self, 'values')
|
@property
@pulumi.getter
def values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
'\n \n '
return pulumi.get(self, 'values')<|docstring|>An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.<|endoftext|>
|
bf5e44d0e580083b08c3f5d19b06e03c46a981848dd902f10b7e1e615be95e67
|
def __init__(__self__, *, key: pulumi.Input[str], operator: pulumi.Input[str], values: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None):
"\n A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.\n :param pulumi.Input[str] key: The label key that the selector applies to.\n :param pulumi.Input[str] operator: Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] values: An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.\n "
pulumi.set(__self__, 'key', key)
pulumi.set(__self__, 'operator', operator)
if (values is not None):
pulumi.set(__self__, 'values', values)
|
A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
:param pulumi.Input[str] key: The label key that the selector applies to.
:param pulumi.Input[str] operator: Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.
:param pulumi.Input[Sequence[pulumi.Input[str]]] values: An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.
|
operators/ibm-block-csi-operator-community/python/pulumi_pulumi_kubernetes_crds_operators_ibm_block_csi_operator_community/csi/v1/_inputs.py
|
__init__
|
pulumi/pulumi-kubernetes-crds
| 0 |
python
|
def __init__(__self__, *, key: pulumi.Input[str], operator: pulumi.Input[str], values: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None):
"\n A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.\n :param pulumi.Input[str] key: The label key that the selector applies to.\n :param pulumi.Input[str] operator: Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] values: An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.\n "
pulumi.set(__self__, 'key', key)
pulumi.set(__self__, 'operator', operator)
if (values is not None):
pulumi.set(__self__, 'values', values)
|
def __init__(__self__, *, key: pulumi.Input[str], operator: pulumi.Input[str], values: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]=None):
"\n A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.\n :param pulumi.Input[str] key: The label key that the selector applies to.\n :param pulumi.Input[str] operator: Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.\n :param pulumi.Input[Sequence[pulumi.Input[str]]] values: An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.\n "
pulumi.set(__self__, 'key', key)
pulumi.set(__self__, 'operator', operator)
if (values is not None):
pulumi.set(__self__, 'values', values)<|docstring|>A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
:param pulumi.Input[str] key: The label key that the selector applies to.
:param pulumi.Input[str] operator: Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.
:param pulumi.Input[Sequence[pulumi.Input[str]]] values: An array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.<|endoftext|>
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.