pulumi-linode 5.1.0a1752772340__py3-none-any.whl → 5.1.1a1753933550__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Potentially problematic release.
This version of pulumi-linode might be problematic. Click here for more details.
- pulumi_linode/__init__.py +1 -1
- pulumi_linode/_inputs.py +5224 -5147
- pulumi_linode/account_settings.py +70 -71
- pulumi_linode/config/__init__.py +1 -1
- pulumi_linode/config/__init__.pyi +1 -2
- pulumi_linode/config/vars.py +21 -22
- pulumi_linode/database_access_controls.py +52 -53
- pulumi_linode/database_mysql.py +247 -248
- pulumi_linode/database_mysql_v2.py +782 -783
- pulumi_linode/database_postgresql.py +273 -274
- pulumi_linode/database_postgresql_v2.py +1105 -1106
- pulumi_linode/domain.py +222 -223
- pulumi_linode/domain_record.py +188 -189
- pulumi_linode/firewall.py +155 -156
- pulumi_linode/firewall_device.py +70 -71
- pulumi_linode/get_account.py +33 -34
- pulumi_linode/get_account_availabilities.py +5 -6
- pulumi_linode/get_account_availability.py +13 -14
- pulumi_linode/get_account_login.py +17 -18
- pulumi_linode/get_account_logins.py +5 -6
- pulumi_linode/get_account_settings.py +13 -14
- pulumi_linode/get_child_account.py +37 -38
- pulumi_linode/get_child_accounts.py +5 -6
- pulumi_linode/get_database_backups.py +35 -36
- pulumi_linode/get_database_engines.py +23 -24
- pulumi_linode/get_database_mysql.py +52 -53
- pulumi_linode/get_database_mysql_backups.py +29 -30
- pulumi_linode/get_database_mysql_config.py +5 -6
- pulumi_linode/get_database_mysql_v2.py +115 -116
- pulumi_linode/get_database_postgresql.py +56 -57
- pulumi_linode/get_database_postgresql_config.py +7 -8
- pulumi_linode/get_database_postgresql_v2.py +153 -154
- pulumi_linode/get_databases.py +17 -18
- pulumi_linode/get_domain.py +37 -38
- pulumi_linode/get_domain_record.py +37 -38
- pulumi_linode/get_domain_zonefile.py +11 -12
- pulumi_linode/get_domains.py +17 -18
- pulumi_linode/get_firewall.py +30 -31
- pulumi_linode/get_firewalls.py +17 -18
- pulumi_linode/get_image.py +36 -37
- pulumi_linode/get_images.py +23 -24
- pulumi_linode/get_instance_backups.py +12 -13
- pulumi_linode/get_instance_networking.py +11 -12
- pulumi_linode/get_instance_type.py +30 -31
- pulumi_linode/get_instance_types.py +17 -18
- pulumi_linode/get_instances.py +17 -18
- pulumi_linode/get_ipv6_range.py +17 -18
- pulumi_linode/get_ipv6_ranges.py +5 -6
- pulumi_linode/get_kernel.py +23 -24
- pulumi_linode/get_kernels.py +17 -18
- pulumi_linode/get_linode_object_storage_bucket.py +33 -34
- pulumi_linode/get_lke_cluster.py +34 -35
- pulumi_linode/get_lke_clusters.py +17 -18
- pulumi_linode/get_lke_types.py +17 -18
- pulumi_linode/get_lke_version.py +13 -14
- pulumi_linode/get_lke_versions.py +10 -11
- pulumi_linode/get_nb_types.py +13 -14
- pulumi_linode/get_network_transfer_prices.py +17 -18
- pulumi_linode/get_networking_ip.py +28 -29
- pulumi_linode/get_networking_ips.py +17 -18
- pulumi_linode/get_node_balancer.py +29 -30
- pulumi_linode/get_node_balancer_config.py +48 -49
- pulumi_linode/get_node_balancer_node.py +29 -30
- pulumi_linode/get_nodebalancer_configs.py +23 -24
- pulumi_linode/get_nodebalancers.py +17 -18
- pulumi_linode/get_object_storage_cluster.py +15 -16
- pulumi_linode/get_object_storage_endpoints.py +17 -18
- pulumi_linode/get_object_storage_quota.py +22 -23
- pulumi_linode/get_object_storage_quotas.py +5 -6
- pulumi_linode/get_placement_group.py +19 -20
- pulumi_linode/get_placement_groups.py +13 -14
- pulumi_linode/get_profile.py +22 -23
- pulumi_linode/get_region.py +19 -20
- pulumi_linode/get_regions.py +5 -6
- pulumi_linode/get_ssh_key.py +17 -18
- pulumi_linode/get_sshkeys.py +17 -18
- pulumi_linode/get_stack_script.py +32 -33
- pulumi_linode/get_stack_scripts.py +23 -24
- pulumi_linode/get_user.py +35 -36
- pulumi_linode/get_users.py +17 -18
- pulumi_linode/get_vlans.py +17 -18
- pulumi_linode/get_volume.py +27 -28
- pulumi_linode/get_volume_types.py +17 -18
- pulumi_linode/get_volumes.py +17 -18
- pulumi_linode/get_vpc.py +17 -18
- pulumi_linode/get_vpc_ips.py +11 -12
- pulumi_linode/get_vpc_subnet.py +22 -23
- pulumi_linode/get_vpc_subnets.py +11 -12
- pulumi_linode/get_vpcs.py +5 -6
- pulumi_linode/image.py +292 -293
- pulumi_linode/instance.py +520 -521
- pulumi_linode/instance_config.py +166 -167
- pulumi_linode/instance_disk.py +210 -211
- pulumi_linode/instance_ip.py +125 -126
- pulumi_linode/instance_shared_ips.py +35 -36
- pulumi_linode/ipv6_range.py +88 -89
- pulumi_linode/lke_cluster.py +162 -163
- pulumi_linode/lke_node_pool.py +137 -138
- pulumi_linode/networking_ip.py +133 -134
- pulumi_linode/networking_ip_assignment.py +21 -22
- pulumi_linode/node_balancer.py +152 -153
- pulumi_linode/node_balancer_config.py +319 -320
- pulumi_linode/node_balancer_node.py +112 -113
- pulumi_linode/object_storage_bucket.py +195 -196
- pulumi_linode/object_storage_key.py +67 -68
- pulumi_linode/object_storage_object.py +350 -351
- pulumi_linode/outputs.py +5340 -5291
- pulumi_linode/placement_group.py +80 -81
- pulumi_linode/placement_group_assignment.py +48 -49
- pulumi_linode/provider.py +180 -181
- pulumi_linode/pulumi-plugin.json +1 -1
- pulumi_linode/rdns.py +55 -56
- pulumi_linode/reserved_ip_assignment.py +142 -143
- pulumi_linode/ssh_key.py +44 -45
- pulumi_linode/stack_script.py +159 -160
- pulumi_linode/token.py +70 -71
- pulumi_linode/user.py +112 -113
- pulumi_linode/volume.py +141 -142
- pulumi_linode/vpc.py +70 -71
- pulumi_linode/vpc_subnet.py +72 -73
- {pulumi_linode-5.1.0a1752772340.dist-info → pulumi_linode-5.1.1a1753933550.dist-info}/METADATA +1 -1
- pulumi_linode-5.1.1a1753933550.dist-info/RECORD +126 -0
- pulumi_linode-5.1.0a1752772340.dist-info/RECORD +0 -126
- {pulumi_linode-5.1.0a1752772340.dist-info → pulumi_linode-5.1.1a1753933550.dist-info}/WHEEL +0 -0
- {pulumi_linode-5.1.0a1752772340.dist-info → pulumi_linode-5.1.1a1753933550.dist-info}/top_level.txt +0 -0
pulumi_linode/lke_node_pool.py
CHANGED
|
@@ -2,8 +2,7 @@
|
|
|
2
2
|
# *** WARNING: this file was generated by pulumi-language-python. ***
|
|
3
3
|
# *** Do not edit by hand unless you're certain you know what you are doing! ***
|
|
4
4
|
|
|
5
|
-
import builtins
|
|
6
|
-
import copy
|
|
5
|
+
import builtins as _builtins
|
|
7
6
|
import warnings
|
|
8
7
|
import sys
|
|
9
8
|
import pulumi
|
|
@@ -22,26 +21,26 @@ __all__ = ['LkeNodePoolArgs', 'LkeNodePool']
|
|
|
22
21
|
@pulumi.input_type
|
|
23
22
|
class LkeNodePoolArgs:
|
|
24
23
|
def __init__(__self__, *,
|
|
25
|
-
cluster_id: pulumi.Input[
|
|
26
|
-
type: pulumi.Input[
|
|
24
|
+
cluster_id: pulumi.Input[_builtins.int],
|
|
25
|
+
type: pulumi.Input[_builtins.str],
|
|
27
26
|
autoscaler: Optional[pulumi.Input['LkeNodePoolAutoscalerArgs']] = None,
|
|
28
|
-
k8s_version: Optional[pulumi.Input[
|
|
29
|
-
labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[
|
|
30
|
-
node_count: Optional[pulumi.Input[
|
|
31
|
-
tags: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
27
|
+
k8s_version: Optional[pulumi.Input[_builtins.str]] = None,
|
|
28
|
+
labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
|
|
29
|
+
node_count: Optional[pulumi.Input[_builtins.int]] = None,
|
|
30
|
+
tags: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
32
31
|
taints: Optional[pulumi.Input[Sequence[pulumi.Input['LkeNodePoolTaintArgs']]]] = None,
|
|
33
|
-
update_strategy: Optional[pulumi.Input[
|
|
32
|
+
update_strategy: Optional[pulumi.Input[_builtins.str]] = None):
|
|
34
33
|
"""
|
|
35
34
|
The set of arguments for constructing a LkeNodePool resource.
|
|
36
|
-
:param pulumi.Input[
|
|
37
|
-
:param pulumi.Input[
|
|
38
|
-
:param pulumi.Input[
|
|
39
|
-
:param pulumi.Input[Mapping[str, pulumi.Input[
|
|
40
|
-
:param pulumi.Input[
|
|
41
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
35
|
+
:param pulumi.Input[_builtins.int] cluster_id: ID of the LKE Cluster where to create the current Node Pool.
|
|
36
|
+
:param pulumi.Input[_builtins.str] type: A Linode Type for all nodes in the Node Pool. See all node types [here](https://api.linode.com/v4/linode/types).
|
|
37
|
+
:param pulumi.Input[_builtins.str] k8s_version: The k8s version of the nodes in this node pool. For LKE enterprise only and may not currently available to all users even under v4beta.
|
|
38
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] labels: A map attribute containing key-value pairs to be added as labels to nodes in the node pool. Labels help classify your nodes and to easily select subsets of objects. To learn more, review [Add Labels and Taints to your LKE Node Pools](https://www.linode.com/docs/products/compute/kubernetes/guides/deploy-and-manage-cluster-with-the-linode-api/#add-labels-and-taints-to-your-lke-node-pools).
|
|
39
|
+
:param pulumi.Input[_builtins.int] node_count: The number of nodes in the Node Pool. If undefined with an autoscaler the initial node count will equal the autoscaler minimum.
|
|
40
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] tags: An array of tags applied to the Node Pool. Tags can be used to flag node pools as externally managed, see Externally Managed Node Pools for more details.
|
|
42
41
|
:param pulumi.Input[Sequence[pulumi.Input['LkeNodePoolTaintArgs']]] taints: Kubernetes taints to add to node pool nodes. Taints help control how pods are scheduled onto nodes, specifically
|
|
43
42
|
allowing them to repel certain pods.
|
|
44
|
-
:param pulumi.Input[
|
|
43
|
+
:param pulumi.Input[_builtins.str] update_strategy: The strategy for updating the node pool k8s version. For LKE enterprise only and may not currently available to all users even under v4beta.
|
|
45
44
|
|
|
46
45
|
* `autoscaler` - (Optional) If defined, an autoscaler will be enabled with the given configuration.
|
|
47
46
|
|
|
@@ -64,31 +63,31 @@ class LkeNodePoolArgs:
|
|
|
64
63
|
if update_strategy is not None:
|
|
65
64
|
pulumi.set(__self__, "update_strategy", update_strategy)
|
|
66
65
|
|
|
67
|
-
@property
|
|
66
|
+
@_builtins.property
|
|
68
67
|
@pulumi.getter(name="clusterId")
|
|
69
|
-
def cluster_id(self) -> pulumi.Input[
|
|
68
|
+
def cluster_id(self) -> pulumi.Input[_builtins.int]:
|
|
70
69
|
"""
|
|
71
70
|
ID of the LKE Cluster where to create the current Node Pool.
|
|
72
71
|
"""
|
|
73
72
|
return pulumi.get(self, "cluster_id")
|
|
74
73
|
|
|
75
74
|
@cluster_id.setter
|
|
76
|
-
def cluster_id(self, value: pulumi.Input[
|
|
75
|
+
def cluster_id(self, value: pulumi.Input[_builtins.int]):
|
|
77
76
|
pulumi.set(self, "cluster_id", value)
|
|
78
77
|
|
|
79
|
-
@property
|
|
78
|
+
@_builtins.property
|
|
80
79
|
@pulumi.getter
|
|
81
|
-
def type(self) -> pulumi.Input[
|
|
80
|
+
def type(self) -> pulumi.Input[_builtins.str]:
|
|
82
81
|
"""
|
|
83
82
|
A Linode Type for all nodes in the Node Pool. See all node types [here](https://api.linode.com/v4/linode/types).
|
|
84
83
|
"""
|
|
85
84
|
return pulumi.get(self, "type")
|
|
86
85
|
|
|
87
86
|
@type.setter
|
|
88
|
-
def type(self, value: pulumi.Input[
|
|
87
|
+
def type(self, value: pulumi.Input[_builtins.str]):
|
|
89
88
|
pulumi.set(self, "type", value)
|
|
90
89
|
|
|
91
|
-
@property
|
|
90
|
+
@_builtins.property
|
|
92
91
|
@pulumi.getter
|
|
93
92
|
def autoscaler(self) -> Optional[pulumi.Input['LkeNodePoolAutoscalerArgs']]:
|
|
94
93
|
return pulumi.get(self, "autoscaler")
|
|
@@ -97,55 +96,55 @@ class LkeNodePoolArgs:
|
|
|
97
96
|
def autoscaler(self, value: Optional[pulumi.Input['LkeNodePoolAutoscalerArgs']]):
|
|
98
97
|
pulumi.set(self, "autoscaler", value)
|
|
99
98
|
|
|
100
|
-
@property
|
|
99
|
+
@_builtins.property
|
|
101
100
|
@pulumi.getter(name="k8sVersion")
|
|
102
|
-
def k8s_version(self) -> Optional[pulumi.Input[
|
|
101
|
+
def k8s_version(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
103
102
|
"""
|
|
104
103
|
The k8s version of the nodes in this node pool. For LKE enterprise only and may not currently available to all users even under v4beta.
|
|
105
104
|
"""
|
|
106
105
|
return pulumi.get(self, "k8s_version")
|
|
107
106
|
|
|
108
107
|
@k8s_version.setter
|
|
109
|
-
def k8s_version(self, value: Optional[pulumi.Input[
|
|
108
|
+
def k8s_version(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
110
109
|
pulumi.set(self, "k8s_version", value)
|
|
111
110
|
|
|
112
|
-
@property
|
|
111
|
+
@_builtins.property
|
|
113
112
|
@pulumi.getter
|
|
114
|
-
def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[
|
|
113
|
+
def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]:
|
|
115
114
|
"""
|
|
116
115
|
A map attribute containing key-value pairs to be added as labels to nodes in the node pool. Labels help classify your nodes and to easily select subsets of objects. To learn more, review [Add Labels and Taints to your LKE Node Pools](https://www.linode.com/docs/products/compute/kubernetes/guides/deploy-and-manage-cluster-with-the-linode-api/#add-labels-and-taints-to-your-lke-node-pools).
|
|
117
116
|
"""
|
|
118
117
|
return pulumi.get(self, "labels")
|
|
119
118
|
|
|
120
119
|
@labels.setter
|
|
121
|
-
def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[
|
|
120
|
+
def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]):
|
|
122
121
|
pulumi.set(self, "labels", value)
|
|
123
122
|
|
|
124
|
-
@property
|
|
123
|
+
@_builtins.property
|
|
125
124
|
@pulumi.getter(name="nodeCount")
|
|
126
|
-
def node_count(self) -> Optional[pulumi.Input[
|
|
125
|
+
def node_count(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
127
126
|
"""
|
|
128
127
|
The number of nodes in the Node Pool. If undefined with an autoscaler the initial node count will equal the autoscaler minimum.
|
|
129
128
|
"""
|
|
130
129
|
return pulumi.get(self, "node_count")
|
|
131
130
|
|
|
132
131
|
@node_count.setter
|
|
133
|
-
def node_count(self, value: Optional[pulumi.Input[
|
|
132
|
+
def node_count(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
134
133
|
pulumi.set(self, "node_count", value)
|
|
135
134
|
|
|
136
|
-
@property
|
|
135
|
+
@_builtins.property
|
|
137
136
|
@pulumi.getter
|
|
138
|
-
def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
137
|
+
def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
139
138
|
"""
|
|
140
139
|
An array of tags applied to the Node Pool. Tags can be used to flag node pools as externally managed, see Externally Managed Node Pools for more details.
|
|
141
140
|
"""
|
|
142
141
|
return pulumi.get(self, "tags")
|
|
143
142
|
|
|
144
143
|
@tags.setter
|
|
145
|
-
def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
144
|
+
def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
146
145
|
pulumi.set(self, "tags", value)
|
|
147
146
|
|
|
148
|
-
@property
|
|
147
|
+
@_builtins.property
|
|
149
148
|
@pulumi.getter
|
|
150
149
|
def taints(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['LkeNodePoolTaintArgs']]]]:
|
|
151
150
|
"""
|
|
@@ -158,9 +157,9 @@ class LkeNodePoolArgs:
|
|
|
158
157
|
def taints(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['LkeNodePoolTaintArgs']]]]):
|
|
159
158
|
pulumi.set(self, "taints", value)
|
|
160
159
|
|
|
161
|
-
@property
|
|
160
|
+
@_builtins.property
|
|
162
161
|
@pulumi.getter(name="updateStrategy")
|
|
163
|
-
def update_strategy(self) -> Optional[pulumi.Input[
|
|
162
|
+
def update_strategy(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
164
163
|
"""
|
|
165
164
|
The strategy for updating the node pool k8s version. For LKE enterprise only and may not currently available to all users even under v4beta.
|
|
166
165
|
|
|
@@ -171,7 +170,7 @@ class LkeNodePoolArgs:
|
|
|
171
170
|
return pulumi.get(self, "update_strategy")
|
|
172
171
|
|
|
173
172
|
@update_strategy.setter
|
|
174
|
-
def update_strategy(self, value: Optional[pulumi.Input[
|
|
173
|
+
def update_strategy(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
175
174
|
pulumi.set(self, "update_strategy", value)
|
|
176
175
|
|
|
177
176
|
|
|
@@ -179,29 +178,29 @@ class LkeNodePoolArgs:
|
|
|
179
178
|
class _LkeNodePoolState:
|
|
180
179
|
def __init__(__self__, *,
|
|
181
180
|
autoscaler: Optional[pulumi.Input['LkeNodePoolAutoscalerArgs']] = None,
|
|
182
|
-
cluster_id: Optional[pulumi.Input[
|
|
183
|
-
disk_encryption: Optional[pulumi.Input[
|
|
184
|
-
k8s_version: Optional[pulumi.Input[
|
|
185
|
-
labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[
|
|
186
|
-
node_count: Optional[pulumi.Input[
|
|
181
|
+
cluster_id: Optional[pulumi.Input[_builtins.int]] = None,
|
|
182
|
+
disk_encryption: Optional[pulumi.Input[_builtins.str]] = None,
|
|
183
|
+
k8s_version: Optional[pulumi.Input[_builtins.str]] = None,
|
|
184
|
+
labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
|
|
185
|
+
node_count: Optional[pulumi.Input[_builtins.int]] = None,
|
|
187
186
|
nodes: Optional[pulumi.Input[Sequence[pulumi.Input['LkeNodePoolNodeArgs']]]] = None,
|
|
188
|
-
tags: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
187
|
+
tags: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
189
188
|
taints: Optional[pulumi.Input[Sequence[pulumi.Input['LkeNodePoolTaintArgs']]]] = None,
|
|
190
|
-
type: Optional[pulumi.Input[
|
|
191
|
-
update_strategy: Optional[pulumi.Input[
|
|
189
|
+
type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
190
|
+
update_strategy: Optional[pulumi.Input[_builtins.str]] = None):
|
|
192
191
|
"""
|
|
193
192
|
Input properties used for looking up and filtering LkeNodePool resources.
|
|
194
|
-
:param pulumi.Input[
|
|
195
|
-
:param pulumi.Input[
|
|
196
|
-
:param pulumi.Input[
|
|
197
|
-
:param pulumi.Input[Mapping[str, pulumi.Input[
|
|
198
|
-
:param pulumi.Input[
|
|
193
|
+
:param pulumi.Input[_builtins.int] cluster_id: ID of the LKE Cluster where to create the current Node Pool.
|
|
194
|
+
:param pulumi.Input[_builtins.str] disk_encryption: The disk encryption policy for nodes in this pool.
|
|
195
|
+
:param pulumi.Input[_builtins.str] k8s_version: The k8s version of the nodes in this node pool. For LKE enterprise only and may not currently available to all users even under v4beta.
|
|
196
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] labels: A map attribute containing key-value pairs to be added as labels to nodes in the node pool. Labels help classify your nodes and to easily select subsets of objects. To learn more, review [Add Labels and Taints to your LKE Node Pools](https://www.linode.com/docs/products/compute/kubernetes/guides/deploy-and-manage-cluster-with-the-linode-api/#add-labels-and-taints-to-your-lke-node-pools).
|
|
197
|
+
:param pulumi.Input[_builtins.int] node_count: The number of nodes in the Node Pool. If undefined with an autoscaler the initial node count will equal the autoscaler minimum.
|
|
199
198
|
:param pulumi.Input[Sequence[pulumi.Input['LkeNodePoolNodeArgs']]] nodes: A list of nodes in the node pool.
|
|
200
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
199
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] tags: An array of tags applied to the Node Pool. Tags can be used to flag node pools as externally managed, see Externally Managed Node Pools for more details.
|
|
201
200
|
:param pulumi.Input[Sequence[pulumi.Input['LkeNodePoolTaintArgs']]] taints: Kubernetes taints to add to node pool nodes. Taints help control how pods are scheduled onto nodes, specifically
|
|
202
201
|
allowing them to repel certain pods.
|
|
203
|
-
:param pulumi.Input[
|
|
204
|
-
:param pulumi.Input[
|
|
202
|
+
:param pulumi.Input[_builtins.str] type: A Linode Type for all nodes in the Node Pool. See all node types [here](https://api.linode.com/v4/linode/types).
|
|
203
|
+
:param pulumi.Input[_builtins.str] update_strategy: The strategy for updating the node pool k8s version. For LKE enterprise only and may not currently available to all users even under v4beta.
|
|
205
204
|
|
|
206
205
|
* `autoscaler` - (Optional) If defined, an autoscaler will be enabled with the given configuration.
|
|
207
206
|
|
|
@@ -230,7 +229,7 @@ class _LkeNodePoolState:
|
|
|
230
229
|
if update_strategy is not None:
|
|
231
230
|
pulumi.set(__self__, "update_strategy", update_strategy)
|
|
232
231
|
|
|
233
|
-
@property
|
|
232
|
+
@_builtins.property
|
|
234
233
|
@pulumi.getter
|
|
235
234
|
def autoscaler(self) -> Optional[pulumi.Input['LkeNodePoolAutoscalerArgs']]:
|
|
236
235
|
return pulumi.get(self, "autoscaler")
|
|
@@ -239,67 +238,67 @@ class _LkeNodePoolState:
|
|
|
239
238
|
def autoscaler(self, value: Optional[pulumi.Input['LkeNodePoolAutoscalerArgs']]):
|
|
240
239
|
pulumi.set(self, "autoscaler", value)
|
|
241
240
|
|
|
242
|
-
@property
|
|
241
|
+
@_builtins.property
|
|
243
242
|
@pulumi.getter(name="clusterId")
|
|
244
|
-
def cluster_id(self) -> Optional[pulumi.Input[
|
|
243
|
+
def cluster_id(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
245
244
|
"""
|
|
246
245
|
ID of the LKE Cluster where to create the current Node Pool.
|
|
247
246
|
"""
|
|
248
247
|
return pulumi.get(self, "cluster_id")
|
|
249
248
|
|
|
250
249
|
@cluster_id.setter
|
|
251
|
-
def cluster_id(self, value: Optional[pulumi.Input[
|
|
250
|
+
def cluster_id(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
252
251
|
pulumi.set(self, "cluster_id", value)
|
|
253
252
|
|
|
254
|
-
@property
|
|
253
|
+
@_builtins.property
|
|
255
254
|
@pulumi.getter(name="diskEncryption")
|
|
256
|
-
def disk_encryption(self) -> Optional[pulumi.Input[
|
|
255
|
+
def disk_encryption(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
257
256
|
"""
|
|
258
257
|
The disk encryption policy for nodes in this pool.
|
|
259
258
|
"""
|
|
260
259
|
return pulumi.get(self, "disk_encryption")
|
|
261
260
|
|
|
262
261
|
@disk_encryption.setter
|
|
263
|
-
def disk_encryption(self, value: Optional[pulumi.Input[
|
|
262
|
+
def disk_encryption(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
264
263
|
pulumi.set(self, "disk_encryption", value)
|
|
265
264
|
|
|
266
|
-
@property
|
|
265
|
+
@_builtins.property
|
|
267
266
|
@pulumi.getter(name="k8sVersion")
|
|
268
|
-
def k8s_version(self) -> Optional[pulumi.Input[
|
|
267
|
+
def k8s_version(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
269
268
|
"""
|
|
270
269
|
The k8s version of the nodes in this node pool. For LKE enterprise only and may not currently available to all users even under v4beta.
|
|
271
270
|
"""
|
|
272
271
|
return pulumi.get(self, "k8s_version")
|
|
273
272
|
|
|
274
273
|
@k8s_version.setter
|
|
275
|
-
def k8s_version(self, value: Optional[pulumi.Input[
|
|
274
|
+
def k8s_version(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
276
275
|
pulumi.set(self, "k8s_version", value)
|
|
277
276
|
|
|
278
|
-
@property
|
|
277
|
+
@_builtins.property
|
|
279
278
|
@pulumi.getter
|
|
280
|
-
def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[
|
|
279
|
+
def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]:
|
|
281
280
|
"""
|
|
282
281
|
A map attribute containing key-value pairs to be added as labels to nodes in the node pool. Labels help classify your nodes and to easily select subsets of objects. To learn more, review [Add Labels and Taints to your LKE Node Pools](https://www.linode.com/docs/products/compute/kubernetes/guides/deploy-and-manage-cluster-with-the-linode-api/#add-labels-and-taints-to-your-lke-node-pools).
|
|
283
282
|
"""
|
|
284
283
|
return pulumi.get(self, "labels")
|
|
285
284
|
|
|
286
285
|
@labels.setter
|
|
287
|
-
def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[
|
|
286
|
+
def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]):
|
|
288
287
|
pulumi.set(self, "labels", value)
|
|
289
288
|
|
|
290
|
-
@property
|
|
289
|
+
@_builtins.property
|
|
291
290
|
@pulumi.getter(name="nodeCount")
|
|
292
|
-
def node_count(self) -> Optional[pulumi.Input[
|
|
291
|
+
def node_count(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
293
292
|
"""
|
|
294
293
|
The number of nodes in the Node Pool. If undefined with an autoscaler the initial node count will equal the autoscaler minimum.
|
|
295
294
|
"""
|
|
296
295
|
return pulumi.get(self, "node_count")
|
|
297
296
|
|
|
298
297
|
@node_count.setter
|
|
299
|
-
def node_count(self, value: Optional[pulumi.Input[
|
|
298
|
+
def node_count(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
300
299
|
pulumi.set(self, "node_count", value)
|
|
301
300
|
|
|
302
|
-
@property
|
|
301
|
+
@_builtins.property
|
|
303
302
|
@pulumi.getter
|
|
304
303
|
def nodes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['LkeNodePoolNodeArgs']]]]:
|
|
305
304
|
"""
|
|
@@ -311,19 +310,19 @@ class _LkeNodePoolState:
|
|
|
311
310
|
def nodes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['LkeNodePoolNodeArgs']]]]):
|
|
312
311
|
pulumi.set(self, "nodes", value)
|
|
313
312
|
|
|
314
|
-
@property
|
|
313
|
+
@_builtins.property
|
|
315
314
|
@pulumi.getter
|
|
316
|
-
def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
315
|
+
def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
317
316
|
"""
|
|
318
317
|
An array of tags applied to the Node Pool. Tags can be used to flag node pools as externally managed, see Externally Managed Node Pools for more details.
|
|
319
318
|
"""
|
|
320
319
|
return pulumi.get(self, "tags")
|
|
321
320
|
|
|
322
321
|
@tags.setter
|
|
323
|
-
def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
322
|
+
def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
324
323
|
pulumi.set(self, "tags", value)
|
|
325
324
|
|
|
326
|
-
@property
|
|
325
|
+
@_builtins.property
|
|
327
326
|
@pulumi.getter
|
|
328
327
|
def taints(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['LkeNodePoolTaintArgs']]]]:
|
|
329
328
|
"""
|
|
@@ -336,21 +335,21 @@ class _LkeNodePoolState:
|
|
|
336
335
|
def taints(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['LkeNodePoolTaintArgs']]]]):
|
|
337
336
|
pulumi.set(self, "taints", value)
|
|
338
337
|
|
|
339
|
-
@property
|
|
338
|
+
@_builtins.property
|
|
340
339
|
@pulumi.getter
|
|
341
|
-
def type(self) -> Optional[pulumi.Input[
|
|
340
|
+
def type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
342
341
|
"""
|
|
343
342
|
A Linode Type for all nodes in the Node Pool. See all node types [here](https://api.linode.com/v4/linode/types).
|
|
344
343
|
"""
|
|
345
344
|
return pulumi.get(self, "type")
|
|
346
345
|
|
|
347
346
|
@type.setter
|
|
348
|
-
def type(self, value: Optional[pulumi.Input[
|
|
347
|
+
def type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
349
348
|
pulumi.set(self, "type", value)
|
|
350
349
|
|
|
351
|
-
@property
|
|
350
|
+
@_builtins.property
|
|
352
351
|
@pulumi.getter(name="updateStrategy")
|
|
353
|
-
def update_strategy(self) -> Optional[pulumi.Input[
|
|
352
|
+
def update_strategy(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
354
353
|
"""
|
|
355
354
|
The strategy for updating the node pool k8s version. For LKE enterprise only and may not currently available to all users even under v4beta.
|
|
356
355
|
|
|
@@ -361,7 +360,7 @@ class _LkeNodePoolState:
|
|
|
361
360
|
return pulumi.get(self, "update_strategy")
|
|
362
361
|
|
|
363
362
|
@update_strategy.setter
|
|
364
|
-
def update_strategy(self, value: Optional[pulumi.Input[
|
|
363
|
+
def update_strategy(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
365
364
|
pulumi.set(self, "update_strategy", value)
|
|
366
365
|
|
|
367
366
|
|
|
@@ -372,14 +371,14 @@ class LkeNodePool(pulumi.CustomResource):
|
|
|
372
371
|
resource_name: str,
|
|
373
372
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
374
373
|
autoscaler: Optional[pulumi.Input[Union['LkeNodePoolAutoscalerArgs', 'LkeNodePoolAutoscalerArgsDict']]] = None,
|
|
375
|
-
cluster_id: Optional[pulumi.Input[
|
|
376
|
-
k8s_version: Optional[pulumi.Input[
|
|
377
|
-
labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[
|
|
378
|
-
node_count: Optional[pulumi.Input[
|
|
379
|
-
tags: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
374
|
+
cluster_id: Optional[pulumi.Input[_builtins.int]] = None,
|
|
375
|
+
k8s_version: Optional[pulumi.Input[_builtins.str]] = None,
|
|
376
|
+
labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
|
|
377
|
+
node_count: Optional[pulumi.Input[_builtins.int]] = None,
|
|
378
|
+
tags: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
380
379
|
taints: Optional[pulumi.Input[Sequence[pulumi.Input[Union['LkeNodePoolTaintArgs', 'LkeNodePoolTaintArgsDict']]]]] = None,
|
|
381
|
-
type: Optional[pulumi.Input[
|
|
382
|
-
update_strategy: Optional[pulumi.Input[
|
|
380
|
+
type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
381
|
+
update_strategy: Optional[pulumi.Input[_builtins.str]] = None,
|
|
383
382
|
__props__=None):
|
|
384
383
|
"""
|
|
385
384
|
## Import
|
|
@@ -392,15 +391,15 @@ class LkeNodePool(pulumi.CustomResource):
|
|
|
392
391
|
|
|
393
392
|
:param str resource_name: The name of the resource.
|
|
394
393
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
395
|
-
:param pulumi.Input[
|
|
396
|
-
:param pulumi.Input[
|
|
397
|
-
:param pulumi.Input[Mapping[str, pulumi.Input[
|
|
398
|
-
:param pulumi.Input[
|
|
399
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
394
|
+
:param pulumi.Input[_builtins.int] cluster_id: ID of the LKE Cluster where to create the current Node Pool.
|
|
395
|
+
:param pulumi.Input[_builtins.str] k8s_version: The k8s version of the nodes in this node pool. For LKE enterprise only and may not currently available to all users even under v4beta.
|
|
396
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] labels: A map attribute containing key-value pairs to be added as labels to nodes in the node pool. Labels help classify your nodes and to easily select subsets of objects. To learn more, review [Add Labels and Taints to your LKE Node Pools](https://www.linode.com/docs/products/compute/kubernetes/guides/deploy-and-manage-cluster-with-the-linode-api/#add-labels-and-taints-to-your-lke-node-pools).
|
|
397
|
+
:param pulumi.Input[_builtins.int] node_count: The number of nodes in the Node Pool. If undefined with an autoscaler the initial node count will equal the autoscaler minimum.
|
|
398
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] tags: An array of tags applied to the Node Pool. Tags can be used to flag node pools as externally managed, see Externally Managed Node Pools for more details.
|
|
400
399
|
:param pulumi.Input[Sequence[pulumi.Input[Union['LkeNodePoolTaintArgs', 'LkeNodePoolTaintArgsDict']]]] taints: Kubernetes taints to add to node pool nodes. Taints help control how pods are scheduled onto nodes, specifically
|
|
401
400
|
allowing them to repel certain pods.
|
|
402
|
-
:param pulumi.Input[
|
|
403
|
-
:param pulumi.Input[
|
|
401
|
+
:param pulumi.Input[_builtins.str] type: A Linode Type for all nodes in the Node Pool. See all node types [here](https://api.linode.com/v4/linode/types).
|
|
402
|
+
:param pulumi.Input[_builtins.str] update_strategy: The strategy for updating the node pool k8s version. For LKE enterprise only and may not currently available to all users even under v4beta.
|
|
404
403
|
|
|
405
404
|
* `autoscaler` - (Optional) If defined, an autoscaler will be enabled with the given configuration.
|
|
406
405
|
|
|
@@ -437,14 +436,14 @@ class LkeNodePool(pulumi.CustomResource):
|
|
|
437
436
|
resource_name: str,
|
|
438
437
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
439
438
|
autoscaler: Optional[pulumi.Input[Union['LkeNodePoolAutoscalerArgs', 'LkeNodePoolAutoscalerArgsDict']]] = None,
|
|
440
|
-
cluster_id: Optional[pulumi.Input[
|
|
441
|
-
k8s_version: Optional[pulumi.Input[
|
|
442
|
-
labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[
|
|
443
|
-
node_count: Optional[pulumi.Input[
|
|
444
|
-
tags: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
439
|
+
cluster_id: Optional[pulumi.Input[_builtins.int]] = None,
|
|
440
|
+
k8s_version: Optional[pulumi.Input[_builtins.str]] = None,
|
|
441
|
+
labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
|
|
442
|
+
node_count: Optional[pulumi.Input[_builtins.int]] = None,
|
|
443
|
+
tags: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
445
444
|
taints: Optional[pulumi.Input[Sequence[pulumi.Input[Union['LkeNodePoolTaintArgs', 'LkeNodePoolTaintArgsDict']]]]] = None,
|
|
446
|
-
type: Optional[pulumi.Input[
|
|
447
|
-
update_strategy: Optional[pulumi.Input[
|
|
445
|
+
type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
446
|
+
update_strategy: Optional[pulumi.Input[_builtins.str]] = None,
|
|
448
447
|
__props__=None):
|
|
449
448
|
opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
|
|
450
449
|
if not isinstance(opts, pulumi.ResourceOptions):
|
|
@@ -480,16 +479,16 @@ class LkeNodePool(pulumi.CustomResource):
|
|
|
480
479
|
id: pulumi.Input[str],
|
|
481
480
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
482
481
|
autoscaler: Optional[pulumi.Input[Union['LkeNodePoolAutoscalerArgs', 'LkeNodePoolAutoscalerArgsDict']]] = None,
|
|
483
|
-
cluster_id: Optional[pulumi.Input[
|
|
484
|
-
disk_encryption: Optional[pulumi.Input[
|
|
485
|
-
k8s_version: Optional[pulumi.Input[
|
|
486
|
-
labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[
|
|
487
|
-
node_count: Optional[pulumi.Input[
|
|
482
|
+
cluster_id: Optional[pulumi.Input[_builtins.int]] = None,
|
|
483
|
+
disk_encryption: Optional[pulumi.Input[_builtins.str]] = None,
|
|
484
|
+
k8s_version: Optional[pulumi.Input[_builtins.str]] = None,
|
|
485
|
+
labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
|
|
486
|
+
node_count: Optional[pulumi.Input[_builtins.int]] = None,
|
|
488
487
|
nodes: Optional[pulumi.Input[Sequence[pulumi.Input[Union['LkeNodePoolNodeArgs', 'LkeNodePoolNodeArgsDict']]]]] = None,
|
|
489
|
-
tags: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
488
|
+
tags: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
490
489
|
taints: Optional[pulumi.Input[Sequence[pulumi.Input[Union['LkeNodePoolTaintArgs', 'LkeNodePoolTaintArgsDict']]]]] = None,
|
|
491
|
-
type: Optional[pulumi.Input[
|
|
492
|
-
update_strategy: Optional[pulumi.Input[
|
|
490
|
+
type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
491
|
+
update_strategy: Optional[pulumi.Input[_builtins.str]] = None) -> 'LkeNodePool':
|
|
493
492
|
"""
|
|
494
493
|
Get an existing LkeNodePool resource's state with the given name, id, and optional extra
|
|
495
494
|
properties used to qualify the lookup.
|
|
@@ -497,17 +496,17 @@ class LkeNodePool(pulumi.CustomResource):
|
|
|
497
496
|
:param str resource_name: The unique name of the resulting resource.
|
|
498
497
|
:param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
|
|
499
498
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
500
|
-
:param pulumi.Input[
|
|
501
|
-
:param pulumi.Input[
|
|
502
|
-
:param pulumi.Input[
|
|
503
|
-
:param pulumi.Input[Mapping[str, pulumi.Input[
|
|
504
|
-
:param pulumi.Input[
|
|
499
|
+
:param pulumi.Input[_builtins.int] cluster_id: ID of the LKE Cluster where to create the current Node Pool.
|
|
500
|
+
:param pulumi.Input[_builtins.str] disk_encryption: The disk encryption policy for nodes in this pool.
|
|
501
|
+
:param pulumi.Input[_builtins.str] k8s_version: The k8s version of the nodes in this node pool. For LKE enterprise only and may not currently available to all users even under v4beta.
|
|
502
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] labels: A map attribute containing key-value pairs to be added as labels to nodes in the node pool. Labels help classify your nodes and to easily select subsets of objects. To learn more, review [Add Labels and Taints to your LKE Node Pools](https://www.linode.com/docs/products/compute/kubernetes/guides/deploy-and-manage-cluster-with-the-linode-api/#add-labels-and-taints-to-your-lke-node-pools).
|
|
503
|
+
:param pulumi.Input[_builtins.int] node_count: The number of nodes in the Node Pool. If undefined with an autoscaler the initial node count will equal the autoscaler minimum.
|
|
505
504
|
:param pulumi.Input[Sequence[pulumi.Input[Union['LkeNodePoolNodeArgs', 'LkeNodePoolNodeArgsDict']]]] nodes: A list of nodes in the node pool.
|
|
506
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
505
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] tags: An array of tags applied to the Node Pool. Tags can be used to flag node pools as externally managed, see Externally Managed Node Pools for more details.
|
|
507
506
|
:param pulumi.Input[Sequence[pulumi.Input[Union['LkeNodePoolTaintArgs', 'LkeNodePoolTaintArgsDict']]]] taints: Kubernetes taints to add to node pool nodes. Taints help control how pods are scheduled onto nodes, specifically
|
|
508
507
|
allowing them to repel certain pods.
|
|
509
|
-
:param pulumi.Input[
|
|
510
|
-
:param pulumi.Input[
|
|
508
|
+
:param pulumi.Input[_builtins.str] type: A Linode Type for all nodes in the Node Pool. See all node types [here](https://api.linode.com/v4/linode/types).
|
|
509
|
+
:param pulumi.Input[_builtins.str] update_strategy: The strategy for updating the node pool k8s version. For LKE enterprise only and may not currently available to all users even under v4beta.
|
|
511
510
|
|
|
512
511
|
* `autoscaler` - (Optional) If defined, an autoscaler will be enabled with the given configuration.
|
|
513
512
|
|
|
@@ -530,52 +529,52 @@ class LkeNodePool(pulumi.CustomResource):
|
|
|
530
529
|
__props__.__dict__["update_strategy"] = update_strategy
|
|
531
530
|
return LkeNodePool(resource_name, opts=opts, __props__=__props__)
|
|
532
531
|
|
|
533
|
-
@property
|
|
532
|
+
@_builtins.property
|
|
534
533
|
@pulumi.getter
|
|
535
534
|
def autoscaler(self) -> pulumi.Output[Optional['outputs.LkeNodePoolAutoscaler']]:
|
|
536
535
|
return pulumi.get(self, "autoscaler")
|
|
537
536
|
|
|
538
|
-
@property
|
|
537
|
+
@_builtins.property
|
|
539
538
|
@pulumi.getter(name="clusterId")
|
|
540
|
-
def cluster_id(self) -> pulumi.Output[
|
|
539
|
+
def cluster_id(self) -> pulumi.Output[_builtins.int]:
|
|
541
540
|
"""
|
|
542
541
|
ID of the LKE Cluster where to create the current Node Pool.
|
|
543
542
|
"""
|
|
544
543
|
return pulumi.get(self, "cluster_id")
|
|
545
544
|
|
|
546
|
-
@property
|
|
545
|
+
@_builtins.property
|
|
547
546
|
@pulumi.getter(name="diskEncryption")
|
|
548
|
-
def disk_encryption(self) -> pulumi.Output[
|
|
547
|
+
def disk_encryption(self) -> pulumi.Output[_builtins.str]:
|
|
549
548
|
"""
|
|
550
549
|
The disk encryption policy for nodes in this pool.
|
|
551
550
|
"""
|
|
552
551
|
return pulumi.get(self, "disk_encryption")
|
|
553
552
|
|
|
554
|
-
@property
|
|
553
|
+
@_builtins.property
|
|
555
554
|
@pulumi.getter(name="k8sVersion")
|
|
556
|
-
def k8s_version(self) -> pulumi.Output[
|
|
555
|
+
def k8s_version(self) -> pulumi.Output[_builtins.str]:
|
|
557
556
|
"""
|
|
558
557
|
The k8s version of the nodes in this node pool. For LKE enterprise only and may not currently available to all users even under v4beta.
|
|
559
558
|
"""
|
|
560
559
|
return pulumi.get(self, "k8s_version")
|
|
561
560
|
|
|
562
|
-
@property
|
|
561
|
+
@_builtins.property
|
|
563
562
|
@pulumi.getter
|
|
564
|
-
def labels(self) -> pulumi.Output[Mapping[str,
|
|
563
|
+
def labels(self) -> pulumi.Output[Mapping[str, _builtins.str]]:
|
|
565
564
|
"""
|
|
566
565
|
A map attribute containing key-value pairs to be added as labels to nodes in the node pool. Labels help classify your nodes and to easily select subsets of objects. To learn more, review [Add Labels and Taints to your LKE Node Pools](https://www.linode.com/docs/products/compute/kubernetes/guides/deploy-and-manage-cluster-with-the-linode-api/#add-labels-and-taints-to-your-lke-node-pools).
|
|
567
566
|
"""
|
|
568
567
|
return pulumi.get(self, "labels")
|
|
569
568
|
|
|
570
|
-
@property
|
|
569
|
+
@_builtins.property
|
|
571
570
|
@pulumi.getter(name="nodeCount")
|
|
572
|
-
def node_count(self) -> pulumi.Output[
|
|
571
|
+
def node_count(self) -> pulumi.Output[_builtins.int]:
|
|
573
572
|
"""
|
|
574
573
|
The number of nodes in the Node Pool. If undefined with an autoscaler the initial node count will equal the autoscaler minimum.
|
|
575
574
|
"""
|
|
576
575
|
return pulumi.get(self, "node_count")
|
|
577
576
|
|
|
578
|
-
@property
|
|
577
|
+
@_builtins.property
|
|
579
578
|
@pulumi.getter
|
|
580
579
|
def nodes(self) -> pulumi.Output[Sequence['outputs.LkeNodePoolNode']]:
|
|
581
580
|
"""
|
|
@@ -583,15 +582,15 @@ class LkeNodePool(pulumi.CustomResource):
|
|
|
583
582
|
"""
|
|
584
583
|
return pulumi.get(self, "nodes")
|
|
585
584
|
|
|
586
|
-
@property
|
|
585
|
+
@_builtins.property
|
|
587
586
|
@pulumi.getter
|
|
588
|
-
def tags(self) -> pulumi.Output[Sequence[
|
|
587
|
+
def tags(self) -> pulumi.Output[Sequence[_builtins.str]]:
|
|
589
588
|
"""
|
|
590
589
|
An array of tags applied to the Node Pool. Tags can be used to flag node pools as externally managed, see Externally Managed Node Pools for more details.
|
|
591
590
|
"""
|
|
592
591
|
return pulumi.get(self, "tags")
|
|
593
592
|
|
|
594
|
-
@property
|
|
593
|
+
@_builtins.property
|
|
595
594
|
@pulumi.getter
|
|
596
595
|
def taints(self) -> pulumi.Output[Optional[Sequence['outputs.LkeNodePoolTaint']]]:
|
|
597
596
|
"""
|
|
@@ -600,17 +599,17 @@ class LkeNodePool(pulumi.CustomResource):
|
|
|
600
599
|
"""
|
|
601
600
|
return pulumi.get(self, "taints")
|
|
602
601
|
|
|
603
|
-
@property
|
|
602
|
+
@_builtins.property
|
|
604
603
|
@pulumi.getter
|
|
605
|
-
def type(self) -> pulumi.Output[
|
|
604
|
+
def type(self) -> pulumi.Output[_builtins.str]:
|
|
606
605
|
"""
|
|
607
606
|
A Linode Type for all nodes in the Node Pool. See all node types [here](https://api.linode.com/v4/linode/types).
|
|
608
607
|
"""
|
|
609
608
|
return pulumi.get(self, "type")
|
|
610
609
|
|
|
611
|
-
@property
|
|
610
|
+
@_builtins.property
|
|
612
611
|
@pulumi.getter(name="updateStrategy")
|
|
613
|
-
def update_strategy(self) -> pulumi.Output[
|
|
612
|
+
def update_strategy(self) -> pulumi.Output[_builtins.str]:
|
|
614
613
|
"""
|
|
615
614
|
The strategy for updating the node pool k8s version. For LKE enterprise only and may not currently available to all users even under v4beta.
|
|
616
615
|
|