pulumi-linode 5.3.0a1757052548__py3-none-any.whl → 5.4.0__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 +2 -0
- pulumi_linode/_inputs.py +1305 -301
- pulumi_linode/database_mysql_v2.py +61 -0
- pulumi_linode/database_postgresql_v2.py +61 -0
- pulumi_linode/get_database_mysql_v2.py +32 -1
- pulumi_linode/get_database_postgresql_v2.py +32 -1
- pulumi_linode/get_databases.py +20 -0
- pulumi_linode/get_lke_cluster.py +46 -4
- pulumi_linode/get_node_balancer.py +15 -4
- pulumi_linode/get_node_balancer_node.py +29 -1
- pulumi_linode/get_nodebalancer_vpc.py +166 -0
- pulumi_linode/get_nodebalancer_vpcs.py +238 -0
- pulumi_linode/get_user.py +1 -16
- pulumi_linode/get_vpc.py +40 -1
- pulumi_linode/get_vpc_ips.py +34 -7
- pulumi_linode/get_vpc_subnet.py +28 -1
- pulumi_linode/get_vpc_subnets.py +16 -0
- pulumi_linode/get_vpcs.py +16 -0
- pulumi_linode/lke_cluster.py +144 -3
- pulumi_linode/node_balancer.py +54 -3
- pulumi_linode/node_balancer_node.py +75 -0
- pulumi_linode/outputs.py +1327 -205
- pulumi_linode/pulumi-plugin.json +1 -1
- pulumi_linode/user.py +0 -51
- pulumi_linode/vpc.py +118 -1
- pulumi_linode/vpc_subnet.py +150 -26
- {pulumi_linode-5.3.0a1757052548.dist-info → pulumi_linode-5.4.0.dist-info}/METADATA +1 -1
- {pulumi_linode-5.3.0a1757052548.dist-info → pulumi_linode-5.4.0.dist-info}/RECORD +30 -28
- {pulumi_linode-5.3.0a1757052548.dist-info → pulumi_linode-5.4.0.dist-info}/WHEEL +0 -0
- {pulumi_linode-5.3.0a1757052548.dist-info → pulumi_linode-5.4.0.dist-info}/top_level.txt +0 -0
pulumi_linode/_inputs.py
CHANGED
|
@@ -19,6 +19,8 @@ __all__ = [
|
|
|
19
19
|
'DatabaseMysqlUpdatesArgsDict',
|
|
20
20
|
'DatabaseMysqlV2PendingUpdateArgs',
|
|
21
21
|
'DatabaseMysqlV2PendingUpdateArgsDict',
|
|
22
|
+
'DatabaseMysqlV2PrivateNetworkArgs',
|
|
23
|
+
'DatabaseMysqlV2PrivateNetworkArgsDict',
|
|
22
24
|
'DatabaseMysqlV2TimeoutsArgs',
|
|
23
25
|
'DatabaseMysqlV2TimeoutsArgsDict',
|
|
24
26
|
'DatabaseMysqlV2UpdatesArgs',
|
|
@@ -27,6 +29,8 @@ __all__ = [
|
|
|
27
29
|
'DatabasePostgresqlUpdatesArgsDict',
|
|
28
30
|
'DatabasePostgresqlV2PendingUpdateArgs',
|
|
29
31
|
'DatabasePostgresqlV2PendingUpdateArgsDict',
|
|
32
|
+
'DatabasePostgresqlV2PrivateNetworkArgs',
|
|
33
|
+
'DatabasePostgresqlV2PrivateNetworkArgsDict',
|
|
30
34
|
'DatabasePostgresqlV2TimeoutsArgs',
|
|
31
35
|
'DatabasePostgresqlV2TimeoutsArgsDict',
|
|
32
36
|
'DatabasePostgresqlV2UpdatesArgs',
|
|
@@ -77,6 +81,12 @@ __all__ = [
|
|
|
77
81
|
'InstanceConfigInterfaceArgsDict',
|
|
78
82
|
'InstanceConfigInterfaceIpv4Args',
|
|
79
83
|
'InstanceConfigInterfaceIpv4ArgsDict',
|
|
84
|
+
'InstanceConfigInterfaceIpv6Args',
|
|
85
|
+
'InstanceConfigInterfaceIpv6ArgsDict',
|
|
86
|
+
'InstanceConfigInterfaceIpv6RangeArgs',
|
|
87
|
+
'InstanceConfigInterfaceIpv6RangeArgsDict',
|
|
88
|
+
'InstanceConfigInterfaceIpv6SlaacArgs',
|
|
89
|
+
'InstanceConfigInterfaceIpv6SlaacArgsDict',
|
|
80
90
|
'InstanceDiskArgs',
|
|
81
91
|
'InstanceDiskArgsDict',
|
|
82
92
|
'InstanceDiskTimeoutsArgs',
|
|
@@ -85,6 +95,12 @@ __all__ = [
|
|
|
85
95
|
'InstanceInterfaceArgsDict',
|
|
86
96
|
'InstanceInterfaceIpv4Args',
|
|
87
97
|
'InstanceInterfaceIpv4ArgsDict',
|
|
98
|
+
'InstanceInterfaceIpv6Args',
|
|
99
|
+
'InstanceInterfaceIpv6ArgsDict',
|
|
100
|
+
'InstanceInterfaceIpv6RangeArgs',
|
|
101
|
+
'InstanceInterfaceIpv6RangeArgsDict',
|
|
102
|
+
'InstanceInterfaceIpv6SlaacArgs',
|
|
103
|
+
'InstanceInterfaceIpv6SlaacArgsDict',
|
|
88
104
|
'InstanceIpVpcNat11Args',
|
|
89
105
|
'InstanceIpVpcNat11ArgsDict',
|
|
90
106
|
'InstanceMetadataArgs',
|
|
@@ -127,6 +143,8 @@ __all__ = [
|
|
|
127
143
|
'NodeBalancerFirewallOutboundArgsDict',
|
|
128
144
|
'NodeBalancerTransferArgs',
|
|
129
145
|
'NodeBalancerTransferArgsDict',
|
|
146
|
+
'NodeBalancerVpcArgs',
|
|
147
|
+
'NodeBalancerVpcArgsDict',
|
|
130
148
|
'ObjectStorageBucketCertArgs',
|
|
131
149
|
'ObjectStorageBucketCertArgsDict',
|
|
132
150
|
'ObjectStorageBucketLifecycleRuleArgs',
|
|
@@ -161,8 +179,6 @@ __all__ = [
|
|
|
161
179
|
'UserLongviewGrantArgsDict',
|
|
162
180
|
'UserNodebalancerGrantArgs',
|
|
163
181
|
'UserNodebalancerGrantArgsDict',
|
|
164
|
-
'UserPlacementGroupGrantArgs',
|
|
165
|
-
'UserPlacementGroupGrantArgsDict',
|
|
166
182
|
'UserStackscriptGrantArgs',
|
|
167
183
|
'UserStackscriptGrantArgsDict',
|
|
168
184
|
'UserVolumeGrantArgs',
|
|
@@ -171,6 +187,10 @@ __all__ = [
|
|
|
171
187
|
'UserVpcGrantArgsDict',
|
|
172
188
|
'VolumeTimeoutsArgs',
|
|
173
189
|
'VolumeTimeoutsArgsDict',
|
|
190
|
+
'VpcIpv6Args',
|
|
191
|
+
'VpcIpv6ArgsDict',
|
|
192
|
+
'VpcSubnetIpv6Args',
|
|
193
|
+
'VpcSubnetIpv6ArgsDict',
|
|
174
194
|
'VpcSubnetLinodeArgs',
|
|
175
195
|
'VpcSubnetLinodeArgsDict',
|
|
176
196
|
'VpcSubnetLinodeInterfaceArgs',
|
|
@@ -199,6 +219,8 @@ __all__ = [
|
|
|
199
219
|
'GetDatabaseMysqlBackupsFilterArgsDict',
|
|
200
220
|
'GetDatabasesDatabaseArgs',
|
|
201
221
|
'GetDatabasesDatabaseArgsDict',
|
|
222
|
+
'GetDatabasesDatabasePrivateNetworkArgs',
|
|
223
|
+
'GetDatabasesDatabasePrivateNetworkArgsDict',
|
|
202
224
|
'GetDatabasesFilterArgs',
|
|
203
225
|
'GetDatabasesFilterArgsDict',
|
|
204
226
|
'GetDomainsDomainArgs',
|
|
@@ -319,6 +341,8 @@ __all__ = [
|
|
|
319
341
|
'GetNodebalancerConfigsNodebalancerConfigArgsDict',
|
|
320
342
|
'GetNodebalancerConfigsNodebalancerConfigNodeStatusArgs',
|
|
321
343
|
'GetNodebalancerConfigsNodebalancerConfigNodeStatusArgsDict',
|
|
344
|
+
'GetNodebalancerVpcsFilterArgs',
|
|
345
|
+
'GetNodebalancerVpcsFilterArgsDict',
|
|
322
346
|
'GetNodebalancersFilterArgs',
|
|
323
347
|
'GetNodebalancersFilterArgsDict',
|
|
324
348
|
'GetNodebalancersNodebalancerArgs',
|
|
@@ -387,8 +411,6 @@ __all__ = [
|
|
|
387
411
|
'GetUserLongviewGrantArgsDict',
|
|
388
412
|
'GetUserNodebalancerGrantArgs',
|
|
389
413
|
'GetUserNodebalancerGrantArgsDict',
|
|
390
|
-
'GetUserPlacementGroupGrantArgs',
|
|
391
|
-
'GetUserPlacementGroupGrantArgsDict',
|
|
392
414
|
'GetUserStackscriptGrantArgs',
|
|
393
415
|
'GetUserStackscriptGrantArgsDict',
|
|
394
416
|
'GetUserVolumeGrantArgs',
|
|
@@ -415,8 +437,6 @@ __all__ = [
|
|
|
415
437
|
'GetUsersUserLongviewGrantArgsDict',
|
|
416
438
|
'GetUsersUserNodebalancerGrantArgs',
|
|
417
439
|
'GetUsersUserNodebalancerGrantArgsDict',
|
|
418
|
-
'GetUsersUserPlacementGroupGrantArgs',
|
|
419
|
-
'GetUsersUserPlacementGroupGrantArgsDict',
|
|
420
440
|
'GetUsersUserStackscriptGrantArgs',
|
|
421
441
|
'GetUsersUserStackscriptGrantArgsDict',
|
|
422
442
|
'GetUsersUserVolumeGrantArgs',
|
|
@@ -443,10 +463,14 @@ __all__ = [
|
|
|
443
463
|
'GetVpcIpsFilterArgsDict',
|
|
444
464
|
'GetVpcIpsVpcIpArgs',
|
|
445
465
|
'GetVpcIpsVpcIpArgsDict',
|
|
466
|
+
'GetVpcIpsVpcIpIpv6AddressArgs',
|
|
467
|
+
'GetVpcIpsVpcIpIpv6AddressArgsDict',
|
|
446
468
|
'GetVpcSubnetsFilterArgs',
|
|
447
469
|
'GetVpcSubnetsFilterArgsDict',
|
|
448
470
|
'GetVpcSubnetsVpcSubnetArgs',
|
|
449
471
|
'GetVpcSubnetsVpcSubnetArgsDict',
|
|
472
|
+
'GetVpcSubnetsVpcSubnetIpv6Args',
|
|
473
|
+
'GetVpcSubnetsVpcSubnetIpv6ArgsDict',
|
|
450
474
|
'GetVpcSubnetsVpcSubnetLinodeArgs',
|
|
451
475
|
'GetVpcSubnetsVpcSubnetLinodeArgsDict',
|
|
452
476
|
'GetVpcSubnetsVpcSubnetLinodeInterfaceArgs',
|
|
@@ -455,6 +479,8 @@ __all__ = [
|
|
|
455
479
|
'GetVpcsFilterArgsDict',
|
|
456
480
|
'GetVpcsVpcArgs',
|
|
457
481
|
'GetVpcsVpcArgsDict',
|
|
482
|
+
'GetVpcsVpcIpv6Args',
|
|
483
|
+
'GetVpcsVpcIpv6ArgsDict',
|
|
458
484
|
]
|
|
459
485
|
|
|
460
486
|
MYPY = False
|
|
@@ -613,6 +639,76 @@ class DatabaseMysqlV2PendingUpdateArgs:
|
|
|
613
639
|
pulumi.set(self, "planned_for", value)
|
|
614
640
|
|
|
615
641
|
|
|
642
|
+
if not MYPY:
|
|
643
|
+
class DatabaseMysqlV2PrivateNetworkArgsDict(TypedDict):
|
|
644
|
+
subnet_id: pulumi.Input[_builtins.int]
|
|
645
|
+
"""
|
|
646
|
+
The ID of the VPC subnet to restrict access to this database using.
|
|
647
|
+
"""
|
|
648
|
+
vpc_id: pulumi.Input[_builtins.int]
|
|
649
|
+
"""
|
|
650
|
+
The ID of the virtual private cloud (VPC) to restrict access to this database using.
|
|
651
|
+
"""
|
|
652
|
+
public_access: NotRequired[pulumi.Input[_builtins.bool]]
|
|
653
|
+
"""
|
|
654
|
+
Set to `true` to allow clients outside of the VPC to connect to the database using a public IP address.
|
|
655
|
+
"""
|
|
656
|
+
elif False:
|
|
657
|
+
DatabaseMysqlV2PrivateNetworkArgsDict: TypeAlias = Mapping[str, Any]
|
|
658
|
+
|
|
659
|
+
@pulumi.input_type
|
|
660
|
+
class DatabaseMysqlV2PrivateNetworkArgs:
|
|
661
|
+
def __init__(__self__, *,
|
|
662
|
+
subnet_id: pulumi.Input[_builtins.int],
|
|
663
|
+
vpc_id: pulumi.Input[_builtins.int],
|
|
664
|
+
public_access: Optional[pulumi.Input[_builtins.bool]] = None):
|
|
665
|
+
"""
|
|
666
|
+
:param pulumi.Input[_builtins.int] subnet_id: The ID of the VPC subnet to restrict access to this database using.
|
|
667
|
+
:param pulumi.Input[_builtins.int] vpc_id: The ID of the virtual private cloud (VPC) to restrict access to this database using.
|
|
668
|
+
:param pulumi.Input[_builtins.bool] public_access: Set to `true` to allow clients outside of the VPC to connect to the database using a public IP address.
|
|
669
|
+
"""
|
|
670
|
+
pulumi.set(__self__, "subnet_id", subnet_id)
|
|
671
|
+
pulumi.set(__self__, "vpc_id", vpc_id)
|
|
672
|
+
if public_access is not None:
|
|
673
|
+
pulumi.set(__self__, "public_access", public_access)
|
|
674
|
+
|
|
675
|
+
@_builtins.property
|
|
676
|
+
@pulumi.getter(name="subnetId")
|
|
677
|
+
def subnet_id(self) -> pulumi.Input[_builtins.int]:
|
|
678
|
+
"""
|
|
679
|
+
The ID of the VPC subnet to restrict access to this database using.
|
|
680
|
+
"""
|
|
681
|
+
return pulumi.get(self, "subnet_id")
|
|
682
|
+
|
|
683
|
+
@subnet_id.setter
|
|
684
|
+
def subnet_id(self, value: pulumi.Input[_builtins.int]):
|
|
685
|
+
pulumi.set(self, "subnet_id", value)
|
|
686
|
+
|
|
687
|
+
@_builtins.property
|
|
688
|
+
@pulumi.getter(name="vpcId")
|
|
689
|
+
def vpc_id(self) -> pulumi.Input[_builtins.int]:
|
|
690
|
+
"""
|
|
691
|
+
The ID of the virtual private cloud (VPC) to restrict access to this database using.
|
|
692
|
+
"""
|
|
693
|
+
return pulumi.get(self, "vpc_id")
|
|
694
|
+
|
|
695
|
+
@vpc_id.setter
|
|
696
|
+
def vpc_id(self, value: pulumi.Input[_builtins.int]):
|
|
697
|
+
pulumi.set(self, "vpc_id", value)
|
|
698
|
+
|
|
699
|
+
@_builtins.property
|
|
700
|
+
@pulumi.getter(name="publicAccess")
|
|
701
|
+
def public_access(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
702
|
+
"""
|
|
703
|
+
Set to `true` to allow clients outside of the VPC to connect to the database using a public IP address.
|
|
704
|
+
"""
|
|
705
|
+
return pulumi.get(self, "public_access")
|
|
706
|
+
|
|
707
|
+
@public_access.setter
|
|
708
|
+
def public_access(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
709
|
+
pulumi.set(self, "public_access", value)
|
|
710
|
+
|
|
711
|
+
|
|
616
712
|
if not MYPY:
|
|
617
713
|
class DatabaseMysqlV2TimeoutsArgsDict(TypedDict):
|
|
618
714
|
create: NotRequired[pulumi.Input[_builtins.str]]
|
|
@@ -897,6 +993,76 @@ class DatabasePostgresqlV2PendingUpdateArgs:
|
|
|
897
993
|
pulumi.set(self, "planned_for", value)
|
|
898
994
|
|
|
899
995
|
|
|
996
|
+
if not MYPY:
|
|
997
|
+
class DatabasePostgresqlV2PrivateNetworkArgsDict(TypedDict):
|
|
998
|
+
subnet_id: pulumi.Input[_builtins.int]
|
|
999
|
+
"""
|
|
1000
|
+
The ID of the VPC subnet to restrict access to this database using.
|
|
1001
|
+
"""
|
|
1002
|
+
vpc_id: pulumi.Input[_builtins.int]
|
|
1003
|
+
"""
|
|
1004
|
+
The ID of the virtual private cloud (VPC) to restrict access to this database using.
|
|
1005
|
+
"""
|
|
1006
|
+
public_access: NotRequired[pulumi.Input[_builtins.bool]]
|
|
1007
|
+
"""
|
|
1008
|
+
Set to `true` to allow clients outside of the VPC to connect to the database using a public IP address.
|
|
1009
|
+
"""
|
|
1010
|
+
elif False:
|
|
1011
|
+
DatabasePostgresqlV2PrivateNetworkArgsDict: TypeAlias = Mapping[str, Any]
|
|
1012
|
+
|
|
1013
|
+
@pulumi.input_type
|
|
1014
|
+
class DatabasePostgresqlV2PrivateNetworkArgs:
|
|
1015
|
+
def __init__(__self__, *,
|
|
1016
|
+
subnet_id: pulumi.Input[_builtins.int],
|
|
1017
|
+
vpc_id: pulumi.Input[_builtins.int],
|
|
1018
|
+
public_access: Optional[pulumi.Input[_builtins.bool]] = None):
|
|
1019
|
+
"""
|
|
1020
|
+
:param pulumi.Input[_builtins.int] subnet_id: The ID of the VPC subnet to restrict access to this database using.
|
|
1021
|
+
:param pulumi.Input[_builtins.int] vpc_id: The ID of the virtual private cloud (VPC) to restrict access to this database using.
|
|
1022
|
+
:param pulumi.Input[_builtins.bool] public_access: Set to `true` to allow clients outside of the VPC to connect to the database using a public IP address.
|
|
1023
|
+
"""
|
|
1024
|
+
pulumi.set(__self__, "subnet_id", subnet_id)
|
|
1025
|
+
pulumi.set(__self__, "vpc_id", vpc_id)
|
|
1026
|
+
if public_access is not None:
|
|
1027
|
+
pulumi.set(__self__, "public_access", public_access)
|
|
1028
|
+
|
|
1029
|
+
@_builtins.property
|
|
1030
|
+
@pulumi.getter(name="subnetId")
|
|
1031
|
+
def subnet_id(self) -> pulumi.Input[_builtins.int]:
|
|
1032
|
+
"""
|
|
1033
|
+
The ID of the VPC subnet to restrict access to this database using.
|
|
1034
|
+
"""
|
|
1035
|
+
return pulumi.get(self, "subnet_id")
|
|
1036
|
+
|
|
1037
|
+
@subnet_id.setter
|
|
1038
|
+
def subnet_id(self, value: pulumi.Input[_builtins.int]):
|
|
1039
|
+
pulumi.set(self, "subnet_id", value)
|
|
1040
|
+
|
|
1041
|
+
@_builtins.property
|
|
1042
|
+
@pulumi.getter(name="vpcId")
|
|
1043
|
+
def vpc_id(self) -> pulumi.Input[_builtins.int]:
|
|
1044
|
+
"""
|
|
1045
|
+
The ID of the virtual private cloud (VPC) to restrict access to this database using.
|
|
1046
|
+
"""
|
|
1047
|
+
return pulumi.get(self, "vpc_id")
|
|
1048
|
+
|
|
1049
|
+
@vpc_id.setter
|
|
1050
|
+
def vpc_id(self, value: pulumi.Input[_builtins.int]):
|
|
1051
|
+
pulumi.set(self, "vpc_id", value)
|
|
1052
|
+
|
|
1053
|
+
@_builtins.property
|
|
1054
|
+
@pulumi.getter(name="publicAccess")
|
|
1055
|
+
def public_access(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1056
|
+
"""
|
|
1057
|
+
Set to `true` to allow clients outside of the VPC to connect to the database using a public IP address.
|
|
1058
|
+
"""
|
|
1059
|
+
return pulumi.get(self, "public_access")
|
|
1060
|
+
|
|
1061
|
+
@public_access.setter
|
|
1062
|
+
def public_access(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1063
|
+
pulumi.set(self, "public_access", value)
|
|
1064
|
+
|
|
1065
|
+
|
|
900
1066
|
if not MYPY:
|
|
901
1067
|
class DatabasePostgresqlV2TimeoutsArgsDict(TypedDict):
|
|
902
1068
|
create: NotRequired[pulumi.Input[_builtins.str]]
|
|
@@ -2883,6 +3049,10 @@ if not MYPY:
|
|
|
2883
3049
|
"""
|
|
2884
3050
|
The IPv4 configuration of the VPC interface.This attribute is only allowed for VPC interfaces.
|
|
2885
3051
|
"""
|
|
3052
|
+
ipv6: NotRequired[pulumi.Input['InstanceConfigInterfaceIpv6ArgsDict']]
|
|
3053
|
+
"""
|
|
3054
|
+
The IPv6 configuration of the VPC interface. This attribute is only allowed for VPC interfaces.
|
|
3055
|
+
"""
|
|
2886
3056
|
label: NotRequired[pulumi.Input[_builtins.str]]
|
|
2887
3057
|
"""
|
|
2888
3058
|
The name of the VLAN to join. This field is only allowed and required for interfaces with the `vlan` purpose.
|
|
@@ -2893,6 +3063,8 @@ if not MYPY:
|
|
|
2893
3063
|
|
|
2894
3064
|
* `ipv4` - (Optional) The IPv4 configuration of the VPC interface. This field is currently only allowed for interfaces with the `vpc` purpose.
|
|
2895
3065
|
|
|
3066
|
+
* `ipv6` - (Optional) The IPv6 configuration of the VPC interface. This field is currently only allowed for interfaces with the `vpc` purpose. NOTE: IPv6 VPCs may not yet be available to all users.
|
|
3067
|
+
|
|
2896
3068
|
The following computed attribute is available in a VPC interface:
|
|
2897
3069
|
"""
|
|
2898
3070
|
subnet_id: NotRequired[pulumi.Input[_builtins.int]]
|
|
@@ -2915,6 +3087,7 @@ class InstanceConfigInterfaceArgs:
|
|
|
2915
3087
|
ip_ranges: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
2916
3088
|
ipam_address: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2917
3089
|
ipv4: Optional[pulumi.Input['InstanceConfigInterfaceIpv4Args']] = None,
|
|
3090
|
+
ipv6: Optional[pulumi.Input['InstanceConfigInterfaceIpv6Args']] = None,
|
|
2918
3091
|
label: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2919
3092
|
primary: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
2920
3093
|
subnet_id: Optional[pulumi.Input[_builtins.int]] = None,
|
|
@@ -2926,11 +3099,14 @@ class InstanceConfigInterfaceArgs:
|
|
|
2926
3099
|
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] ip_ranges: IPv4 CIDR VPC Subnet ranges that are routed to this Interface. IPv6 ranges are also available to select participants in the Beta program.
|
|
2927
3100
|
:param pulumi.Input[_builtins.str] ipam_address: This Network Interface’s private IP address in Classless Inter-Domain Routing (CIDR) notation. (e.g. `10.0.0.1/24`) This field is only allowed for interfaces with the `vlan` purpose.
|
|
2928
3101
|
:param pulumi.Input['InstanceConfigInterfaceIpv4Args'] ipv4: The IPv4 configuration of the VPC interface.This attribute is only allowed for VPC interfaces.
|
|
3102
|
+
:param pulumi.Input['InstanceConfigInterfaceIpv6Args'] ipv6: The IPv6 configuration of the VPC interface. This attribute is only allowed for VPC interfaces.
|
|
2929
3103
|
:param pulumi.Input[_builtins.str] label: The name of the VLAN to join. This field is only allowed and required for interfaces with the `vlan` purpose.
|
|
2930
3104
|
:param pulumi.Input[_builtins.bool] primary: Whether the interface is the primary interface that should have the default route for this Linode. This field is only allowed for interfaces with the `public` or `vpc` purpose.
|
|
2931
3105
|
|
|
2932
3106
|
* `ipv4` - (Optional) The IPv4 configuration of the VPC interface. This field is currently only allowed for interfaces with the `vpc` purpose.
|
|
2933
3107
|
|
|
3108
|
+
* `ipv6` - (Optional) The IPv6 configuration of the VPC interface. This field is currently only allowed for interfaces with the `vpc` purpose. NOTE: IPv6 VPCs may not yet be available to all users.
|
|
3109
|
+
|
|
2934
3110
|
The following computed attribute is available in a VPC interface:
|
|
2935
3111
|
:param pulumi.Input[_builtins.int] subnet_id: The name of the VPC Subnet to join. This field is only allowed and required for interfaces with the `vpc` purpose.
|
|
2936
3112
|
:param pulumi.Input[_builtins.int] vpc_id: The ID of VPC which this interface is attached to.
|
|
@@ -2946,6 +3122,8 @@ class InstanceConfigInterfaceArgs:
|
|
|
2946
3122
|
pulumi.set(__self__, "ipam_address", ipam_address)
|
|
2947
3123
|
if ipv4 is not None:
|
|
2948
3124
|
pulumi.set(__self__, "ipv4", ipv4)
|
|
3125
|
+
if ipv6 is not None:
|
|
3126
|
+
pulumi.set(__self__, "ipv6", ipv6)
|
|
2949
3127
|
if label is not None:
|
|
2950
3128
|
pulumi.set(__self__, "label", label)
|
|
2951
3129
|
if primary is not None:
|
|
@@ -3027,6 +3205,18 @@ class InstanceConfigInterfaceArgs:
|
|
|
3027
3205
|
def ipv4(self, value: Optional[pulumi.Input['InstanceConfigInterfaceIpv4Args']]):
|
|
3028
3206
|
pulumi.set(self, "ipv4", value)
|
|
3029
3207
|
|
|
3208
|
+
@_builtins.property
|
|
3209
|
+
@pulumi.getter
|
|
3210
|
+
def ipv6(self) -> Optional[pulumi.Input['InstanceConfigInterfaceIpv6Args']]:
|
|
3211
|
+
"""
|
|
3212
|
+
The IPv6 configuration of the VPC interface. This attribute is only allowed for VPC interfaces.
|
|
3213
|
+
"""
|
|
3214
|
+
return pulumi.get(self, "ipv6")
|
|
3215
|
+
|
|
3216
|
+
@ipv6.setter
|
|
3217
|
+
def ipv6(self, value: Optional[pulumi.Input['InstanceConfigInterfaceIpv6Args']]):
|
|
3218
|
+
pulumi.set(self, "ipv6", value)
|
|
3219
|
+
|
|
3030
3220
|
@_builtins.property
|
|
3031
3221
|
@pulumi.getter
|
|
3032
3222
|
def label(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
@@ -3047,6 +3237,8 @@ class InstanceConfigInterfaceArgs:
|
|
|
3047
3237
|
|
|
3048
3238
|
* `ipv4` - (Optional) The IPv4 configuration of the VPC interface. This field is currently only allowed for interfaces with the `vpc` purpose.
|
|
3049
3239
|
|
|
3240
|
+
* `ipv6` - (Optional) The IPv6 configuration of the VPC interface. This field is currently only allowed for interfaces with the `vpc` purpose. NOTE: IPv6 VPCs may not yet be available to all users.
|
|
3241
|
+
|
|
3050
3242
|
The following computed attribute is available in a VPC interface:
|
|
3051
3243
|
"""
|
|
3052
3244
|
return pulumi.get(self, "primary")
|
|
@@ -3132,6 +3324,214 @@ class InstanceConfigInterfaceIpv4Args:
|
|
|
3132
3324
|
pulumi.set(self, "vpc", value)
|
|
3133
3325
|
|
|
3134
3326
|
|
|
3327
|
+
if not MYPY:
|
|
3328
|
+
class InstanceConfigInterfaceIpv6ArgsDict(TypedDict):
|
|
3329
|
+
is_public: NotRequired[pulumi.Input[_builtins.bool]]
|
|
3330
|
+
"""
|
|
3331
|
+
If true, connections from the interface to IPv6 addresses outside the VPC, and connections from IPv6 addresses outside the VPC to the interface will be permitted. (Default: `false`)
|
|
3332
|
+
|
|
3333
|
+
* `slaac` - (Optional) An array of SLAAC prefixes to use for this interface.
|
|
3334
|
+
|
|
3335
|
+
* `range` - (Optional) An array of IPv6 ranges to use for this interface.
|
|
3336
|
+
"""
|
|
3337
|
+
ranges: NotRequired[pulumi.Input[Sequence[pulumi.Input['InstanceConfigInterfaceIpv6RangeArgsDict']]]]
|
|
3338
|
+
"""
|
|
3339
|
+
A prefix to add to this interface, or `auto` for a new IPv6 prefix to be automatically allocated.
|
|
3340
|
+
"""
|
|
3341
|
+
slaacs: NotRequired[pulumi.Input[Sequence[pulumi.Input['InstanceConfigInterfaceIpv6SlaacArgsDict']]]]
|
|
3342
|
+
"""
|
|
3343
|
+
An array of SLAAC prefixes to use for this interface.
|
|
3344
|
+
"""
|
|
3345
|
+
elif False:
|
|
3346
|
+
InstanceConfigInterfaceIpv6ArgsDict: TypeAlias = Mapping[str, Any]
|
|
3347
|
+
|
|
3348
|
+
@pulumi.input_type
|
|
3349
|
+
class InstanceConfigInterfaceIpv6Args:
|
|
3350
|
+
def __init__(__self__, *,
|
|
3351
|
+
is_public: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
3352
|
+
ranges: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceConfigInterfaceIpv6RangeArgs']]]] = None,
|
|
3353
|
+
slaacs: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceConfigInterfaceIpv6SlaacArgs']]]] = None):
|
|
3354
|
+
"""
|
|
3355
|
+
:param pulumi.Input[_builtins.bool] is_public: If true, connections from the interface to IPv6 addresses outside the VPC, and connections from IPv6 addresses outside the VPC to the interface will be permitted. (Default: `false`)
|
|
3356
|
+
|
|
3357
|
+
* `slaac` - (Optional) An array of SLAAC prefixes to use for this interface.
|
|
3358
|
+
|
|
3359
|
+
* `range` - (Optional) An array of IPv6 ranges to use for this interface.
|
|
3360
|
+
:param pulumi.Input[Sequence[pulumi.Input['InstanceConfigInterfaceIpv6RangeArgs']]] ranges: A prefix to add to this interface, or `auto` for a new IPv6 prefix to be automatically allocated.
|
|
3361
|
+
:param pulumi.Input[Sequence[pulumi.Input['InstanceConfigInterfaceIpv6SlaacArgs']]] slaacs: An array of SLAAC prefixes to use for this interface.
|
|
3362
|
+
"""
|
|
3363
|
+
if is_public is not None:
|
|
3364
|
+
pulumi.set(__self__, "is_public", is_public)
|
|
3365
|
+
if ranges is not None:
|
|
3366
|
+
pulumi.set(__self__, "ranges", ranges)
|
|
3367
|
+
if slaacs is not None:
|
|
3368
|
+
pulumi.set(__self__, "slaacs", slaacs)
|
|
3369
|
+
|
|
3370
|
+
@_builtins.property
|
|
3371
|
+
@pulumi.getter(name="isPublic")
|
|
3372
|
+
def is_public(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
3373
|
+
"""
|
|
3374
|
+
If true, connections from the interface to IPv6 addresses outside the VPC, and connections from IPv6 addresses outside the VPC to the interface will be permitted. (Default: `false`)
|
|
3375
|
+
|
|
3376
|
+
* `slaac` - (Optional) An array of SLAAC prefixes to use for this interface.
|
|
3377
|
+
|
|
3378
|
+
* `range` - (Optional) An array of IPv6 ranges to use for this interface.
|
|
3379
|
+
"""
|
|
3380
|
+
return pulumi.get(self, "is_public")
|
|
3381
|
+
|
|
3382
|
+
@is_public.setter
|
|
3383
|
+
def is_public(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
3384
|
+
pulumi.set(self, "is_public", value)
|
|
3385
|
+
|
|
3386
|
+
@_builtins.property
|
|
3387
|
+
@pulumi.getter
|
|
3388
|
+
def ranges(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['InstanceConfigInterfaceIpv6RangeArgs']]]]:
|
|
3389
|
+
"""
|
|
3390
|
+
A prefix to add to this interface, or `auto` for a new IPv6 prefix to be automatically allocated.
|
|
3391
|
+
"""
|
|
3392
|
+
return pulumi.get(self, "ranges")
|
|
3393
|
+
|
|
3394
|
+
@ranges.setter
|
|
3395
|
+
def ranges(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceConfigInterfaceIpv6RangeArgs']]]]):
|
|
3396
|
+
pulumi.set(self, "ranges", value)
|
|
3397
|
+
|
|
3398
|
+
@_builtins.property
|
|
3399
|
+
@pulumi.getter
|
|
3400
|
+
def slaacs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['InstanceConfigInterfaceIpv6SlaacArgs']]]]:
|
|
3401
|
+
"""
|
|
3402
|
+
An array of SLAAC prefixes to use for this interface.
|
|
3403
|
+
"""
|
|
3404
|
+
return pulumi.get(self, "slaacs")
|
|
3405
|
+
|
|
3406
|
+
@slaacs.setter
|
|
3407
|
+
def slaacs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceConfigInterfaceIpv6SlaacArgs']]]]):
|
|
3408
|
+
pulumi.set(self, "slaacs", value)
|
|
3409
|
+
|
|
3410
|
+
|
|
3411
|
+
if not MYPY:
|
|
3412
|
+
class InstanceConfigInterfaceIpv6RangeArgsDict(TypedDict):
|
|
3413
|
+
assigned_range: NotRequired[pulumi.Input[_builtins.str]]
|
|
3414
|
+
"""
|
|
3415
|
+
The value of `range` computed by the API. This is necessary when needing to access the range implicitly allocated using `auto`.
|
|
3416
|
+
"""
|
|
3417
|
+
range: NotRequired[pulumi.Input[_builtins.str]]
|
|
3418
|
+
"""
|
|
3419
|
+
A prefix to add to this interface, or `auto` for a new IPv6 prefix to be automatically allocated.
|
|
3420
|
+
"""
|
|
3421
|
+
elif False:
|
|
3422
|
+
InstanceConfigInterfaceIpv6RangeArgsDict: TypeAlias = Mapping[str, Any]
|
|
3423
|
+
|
|
3424
|
+
@pulumi.input_type
|
|
3425
|
+
class InstanceConfigInterfaceIpv6RangeArgs:
|
|
3426
|
+
def __init__(__self__, *,
|
|
3427
|
+
assigned_range: Optional[pulumi.Input[_builtins.str]] = None,
|
|
3428
|
+
range: Optional[pulumi.Input[_builtins.str]] = None):
|
|
3429
|
+
"""
|
|
3430
|
+
:param pulumi.Input[_builtins.str] assigned_range: The value of `range` computed by the API. This is necessary when needing to access the range implicitly allocated using `auto`.
|
|
3431
|
+
:param pulumi.Input[_builtins.str] range: A prefix to add to this interface, or `auto` for a new IPv6 prefix to be automatically allocated.
|
|
3432
|
+
"""
|
|
3433
|
+
if assigned_range is not None:
|
|
3434
|
+
pulumi.set(__self__, "assigned_range", assigned_range)
|
|
3435
|
+
if range is not None:
|
|
3436
|
+
pulumi.set(__self__, "range", range)
|
|
3437
|
+
|
|
3438
|
+
@_builtins.property
|
|
3439
|
+
@pulumi.getter(name="assignedRange")
|
|
3440
|
+
def assigned_range(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
3441
|
+
"""
|
|
3442
|
+
The value of `range` computed by the API. This is necessary when needing to access the range implicitly allocated using `auto`.
|
|
3443
|
+
"""
|
|
3444
|
+
return pulumi.get(self, "assigned_range")
|
|
3445
|
+
|
|
3446
|
+
@assigned_range.setter
|
|
3447
|
+
def assigned_range(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
3448
|
+
pulumi.set(self, "assigned_range", value)
|
|
3449
|
+
|
|
3450
|
+
@_builtins.property
|
|
3451
|
+
@pulumi.getter
|
|
3452
|
+
def range(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
3453
|
+
"""
|
|
3454
|
+
A prefix to add to this interface, or `auto` for a new IPv6 prefix to be automatically allocated.
|
|
3455
|
+
"""
|
|
3456
|
+
return pulumi.get(self, "range")
|
|
3457
|
+
|
|
3458
|
+
@range.setter
|
|
3459
|
+
def range(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
3460
|
+
pulumi.set(self, "range", value)
|
|
3461
|
+
|
|
3462
|
+
|
|
3463
|
+
if not MYPY:
|
|
3464
|
+
class InstanceConfigInterfaceIpv6SlaacArgsDict(TypedDict):
|
|
3465
|
+
address: NotRequired[pulumi.Input[_builtins.str]]
|
|
3466
|
+
"""
|
|
3467
|
+
The SLAAC address chosen for this interface.
|
|
3468
|
+
"""
|
|
3469
|
+
assigned_range: NotRequired[pulumi.Input[_builtins.str]]
|
|
3470
|
+
"""
|
|
3471
|
+
The value of `range` computed by the API. This is necessary when needing to access the range implicitly allocated using `auto`.
|
|
3472
|
+
"""
|
|
3473
|
+
range: NotRequired[pulumi.Input[_builtins.str]]
|
|
3474
|
+
"""
|
|
3475
|
+
A SLAAC prefix to add to this interface, or `auto` for a new IPv6 prefix to be automatically allocated.
|
|
3476
|
+
"""
|
|
3477
|
+
elif False:
|
|
3478
|
+
InstanceConfigInterfaceIpv6SlaacArgsDict: TypeAlias = Mapping[str, Any]
|
|
3479
|
+
|
|
3480
|
+
@pulumi.input_type
|
|
3481
|
+
class InstanceConfigInterfaceIpv6SlaacArgs:
|
|
3482
|
+
def __init__(__self__, *,
|
|
3483
|
+
address: Optional[pulumi.Input[_builtins.str]] = None,
|
|
3484
|
+
assigned_range: Optional[pulumi.Input[_builtins.str]] = None,
|
|
3485
|
+
range: Optional[pulumi.Input[_builtins.str]] = None):
|
|
3486
|
+
"""
|
|
3487
|
+
:param pulumi.Input[_builtins.str] address: The SLAAC address chosen for this interface.
|
|
3488
|
+
:param pulumi.Input[_builtins.str] assigned_range: The value of `range` computed by the API. This is necessary when needing to access the range implicitly allocated using `auto`.
|
|
3489
|
+
:param pulumi.Input[_builtins.str] range: A SLAAC prefix to add to this interface, or `auto` for a new IPv6 prefix to be automatically allocated.
|
|
3490
|
+
"""
|
|
3491
|
+
if address is not None:
|
|
3492
|
+
pulumi.set(__self__, "address", address)
|
|
3493
|
+
if assigned_range is not None:
|
|
3494
|
+
pulumi.set(__self__, "assigned_range", assigned_range)
|
|
3495
|
+
if range is not None:
|
|
3496
|
+
pulumi.set(__self__, "range", range)
|
|
3497
|
+
|
|
3498
|
+
@_builtins.property
|
|
3499
|
+
@pulumi.getter
|
|
3500
|
+
def address(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
3501
|
+
"""
|
|
3502
|
+
The SLAAC address chosen for this interface.
|
|
3503
|
+
"""
|
|
3504
|
+
return pulumi.get(self, "address")
|
|
3505
|
+
|
|
3506
|
+
@address.setter
|
|
3507
|
+
def address(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
3508
|
+
pulumi.set(self, "address", value)
|
|
3509
|
+
|
|
3510
|
+
@_builtins.property
|
|
3511
|
+
@pulumi.getter(name="assignedRange")
|
|
3512
|
+
def assigned_range(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
3513
|
+
"""
|
|
3514
|
+
The value of `range` computed by the API. This is necessary when needing to access the range implicitly allocated using `auto`.
|
|
3515
|
+
"""
|
|
3516
|
+
return pulumi.get(self, "assigned_range")
|
|
3517
|
+
|
|
3518
|
+
@assigned_range.setter
|
|
3519
|
+
def assigned_range(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
3520
|
+
pulumi.set(self, "assigned_range", value)
|
|
3521
|
+
|
|
3522
|
+
@_builtins.property
|
|
3523
|
+
@pulumi.getter
|
|
3524
|
+
def range(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
3525
|
+
"""
|
|
3526
|
+
A SLAAC prefix to add to this interface, or `auto` for a new IPv6 prefix to be automatically allocated.
|
|
3527
|
+
"""
|
|
3528
|
+
return pulumi.get(self, "range")
|
|
3529
|
+
|
|
3530
|
+
@range.setter
|
|
3531
|
+
def range(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
3532
|
+
pulumi.set(self, "range", value)
|
|
3533
|
+
|
|
3534
|
+
|
|
3135
3535
|
if not MYPY:
|
|
3136
3536
|
class InstanceDiskArgsDict(TypedDict):
|
|
3137
3537
|
label: pulumi.Input[_builtins.str]
|
|
@@ -3462,6 +3862,10 @@ if not MYPY:
|
|
|
3462
3862
|
|
|
3463
3863
|
* **NOTE: IP reservation is not currently available to all users.**
|
|
3464
3864
|
"""
|
|
3865
|
+
ipv6: NotRequired[pulumi.Input['InstanceInterfaceIpv6ArgsDict']]
|
|
3866
|
+
"""
|
|
3867
|
+
This Linode's IPv6 SLAAC addresses. This address is specific to a Linode, and may not be shared. The prefix (`/128`) is included in this attribute.
|
|
3868
|
+
"""
|
|
3465
3869
|
label: NotRequired[pulumi.Input[_builtins.str]]
|
|
3466
3870
|
"""
|
|
3467
3871
|
The name of the VLAN to join. This field is only allowed and required for interfaces with the `vlan` purpose.
|
|
@@ -3472,6 +3876,8 @@ if not MYPY:
|
|
|
3472
3876
|
|
|
3473
3877
|
* `ipv4` - (Optional) The IPv4 configuration of the VPC interface. This field is currently only allowed for interfaces with the `vpc` purpose.
|
|
3474
3878
|
|
|
3879
|
+
* `ipv6` - (Optional) The IPv6 configuration of the VPC interface. This field is currently only allowed for interfaces with the `vpc` purpose. NOTE: IPv6 VPCs may not yet be available to all users.
|
|
3880
|
+
|
|
3475
3881
|
The following computed attribute is available in a VPC interface:
|
|
3476
3882
|
"""
|
|
3477
3883
|
subnet_id: NotRequired[pulumi.Input[_builtins.int]]
|
|
@@ -3494,6 +3900,7 @@ class InstanceInterfaceArgs:
|
|
|
3494
3900
|
ip_ranges: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
3495
3901
|
ipam_address: Optional[pulumi.Input[_builtins.str]] = None,
|
|
3496
3902
|
ipv4: Optional[pulumi.Input['InstanceInterfaceIpv4Args']] = None,
|
|
3903
|
+
ipv6: Optional[pulumi.Input['InstanceInterfaceIpv6Args']] = None,
|
|
3497
3904
|
label: Optional[pulumi.Input[_builtins.str]] = None,
|
|
3498
3905
|
primary: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
3499
3906
|
subnet_id: Optional[pulumi.Input[_builtins.int]] = None,
|
|
@@ -3507,11 +3914,14 @@ class InstanceInterfaceArgs:
|
|
|
3507
3914
|
:param pulumi.Input['InstanceInterfaceIpv4Args'] ipv4: A set of reserved IPv4 addresses to assign to this Linode on creation.
|
|
3508
3915
|
|
|
3509
3916
|
* **NOTE: IP reservation is not currently available to all users.**
|
|
3917
|
+
:param pulumi.Input['InstanceInterfaceIpv6Args'] ipv6: This Linode's IPv6 SLAAC addresses. This address is specific to a Linode, and may not be shared. The prefix (`/128`) is included in this attribute.
|
|
3510
3918
|
:param pulumi.Input[_builtins.str] label: The name of the VLAN to join. This field is only allowed and required for interfaces with the `vlan` purpose.
|
|
3511
3919
|
:param pulumi.Input[_builtins.bool] primary: Whether the interface is the primary interface that should have the default route for this Linode. This field is only allowed for interfaces with the `public` or `vpc` purpose.
|
|
3512
3920
|
|
|
3513
3921
|
* `ipv4` - (Optional) The IPv4 configuration of the VPC interface. This field is currently only allowed for interfaces with the `vpc` purpose.
|
|
3514
3922
|
|
|
3923
|
+
* `ipv6` - (Optional) The IPv6 configuration of the VPC interface. This field is currently only allowed for interfaces with the `vpc` purpose. NOTE: IPv6 VPCs may not yet be available to all users.
|
|
3924
|
+
|
|
3515
3925
|
The following computed attribute is available in a VPC interface:
|
|
3516
3926
|
:param pulumi.Input[_builtins.int] subnet_id: The name of the VPC Subnet to join. This field is only allowed and required for interfaces with the `vpc` purpose.
|
|
3517
3927
|
:param pulumi.Input[_builtins.int] vpc_id: The ID of VPC which this interface is attached to.
|
|
@@ -3527,6 +3937,8 @@ class InstanceInterfaceArgs:
|
|
|
3527
3937
|
pulumi.set(__self__, "ipam_address", ipam_address)
|
|
3528
3938
|
if ipv4 is not None:
|
|
3529
3939
|
pulumi.set(__self__, "ipv4", ipv4)
|
|
3940
|
+
if ipv6 is not None:
|
|
3941
|
+
pulumi.set(__self__, "ipv6", ipv6)
|
|
3530
3942
|
if label is not None:
|
|
3531
3943
|
pulumi.set(__self__, "label", label)
|
|
3532
3944
|
if primary is not None:
|
|
@@ -3610,6 +4022,18 @@ class InstanceInterfaceArgs:
|
|
|
3610
4022
|
def ipv4(self, value: Optional[pulumi.Input['InstanceInterfaceIpv4Args']]):
|
|
3611
4023
|
pulumi.set(self, "ipv4", value)
|
|
3612
4024
|
|
|
4025
|
+
@_builtins.property
|
|
4026
|
+
@pulumi.getter
|
|
4027
|
+
def ipv6(self) -> Optional[pulumi.Input['InstanceInterfaceIpv6Args']]:
|
|
4028
|
+
"""
|
|
4029
|
+
This Linode's IPv6 SLAAC addresses. This address is specific to a Linode, and may not be shared. The prefix (`/128`) is included in this attribute.
|
|
4030
|
+
"""
|
|
4031
|
+
return pulumi.get(self, "ipv6")
|
|
4032
|
+
|
|
4033
|
+
@ipv6.setter
|
|
4034
|
+
def ipv6(self, value: Optional[pulumi.Input['InstanceInterfaceIpv6Args']]):
|
|
4035
|
+
pulumi.set(self, "ipv6", value)
|
|
4036
|
+
|
|
3613
4037
|
@_builtins.property
|
|
3614
4038
|
@pulumi.getter
|
|
3615
4039
|
def label(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
@@ -3630,6 +4054,8 @@ class InstanceInterfaceArgs:
|
|
|
3630
4054
|
|
|
3631
4055
|
* `ipv4` - (Optional) The IPv4 configuration of the VPC interface. This field is currently only allowed for interfaces with the `vpc` purpose.
|
|
3632
4056
|
|
|
4057
|
+
* `ipv6` - (Optional) The IPv6 configuration of the VPC interface. This field is currently only allowed for interfaces with the `vpc` purpose. NOTE: IPv6 VPCs may not yet be available to all users.
|
|
4058
|
+
|
|
3633
4059
|
The following computed attribute is available in a VPC interface:
|
|
3634
4060
|
"""
|
|
3635
4061
|
return pulumi.get(self, "primary")
|
|
@@ -3715,6 +4141,214 @@ class InstanceInterfaceIpv4Args:
|
|
|
3715
4141
|
pulumi.set(self, "vpc", value)
|
|
3716
4142
|
|
|
3717
4143
|
|
|
4144
|
+
if not MYPY:
|
|
4145
|
+
class InstanceInterfaceIpv6ArgsDict(TypedDict):
|
|
4146
|
+
is_public: NotRequired[pulumi.Input[_builtins.bool]]
|
|
4147
|
+
"""
|
|
4148
|
+
If true, connections from the interface to IPv6 addresses outside the VPC, and connections from IPv6 addresses outside the VPC to the interface will be permitted. (Default: `false`)
|
|
4149
|
+
|
|
4150
|
+
* `slaac` - (Optional) An array of SLAAC prefixes to use for this interface.
|
|
4151
|
+
|
|
4152
|
+
* `range` - (Optional) An array of IPv6 ranges to use for this interface.
|
|
4153
|
+
"""
|
|
4154
|
+
ranges: NotRequired[pulumi.Input[Sequence[pulumi.Input['InstanceInterfaceIpv6RangeArgsDict']]]]
|
|
4155
|
+
"""
|
|
4156
|
+
A prefix to add to this interface, or `auto` for a new IPv6 prefix to be automatically allocated.
|
|
4157
|
+
"""
|
|
4158
|
+
slaacs: NotRequired[pulumi.Input[Sequence[pulumi.Input['InstanceInterfaceIpv6SlaacArgsDict']]]]
|
|
4159
|
+
"""
|
|
4160
|
+
An array of SLAAC prefixes to use for this interface.
|
|
4161
|
+
"""
|
|
4162
|
+
elif False:
|
|
4163
|
+
InstanceInterfaceIpv6ArgsDict: TypeAlias = Mapping[str, Any]
|
|
4164
|
+
|
|
4165
|
+
@pulumi.input_type
|
|
4166
|
+
class InstanceInterfaceIpv6Args:
|
|
4167
|
+
def __init__(__self__, *,
|
|
4168
|
+
is_public: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
4169
|
+
ranges: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceInterfaceIpv6RangeArgs']]]] = None,
|
|
4170
|
+
slaacs: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceInterfaceIpv6SlaacArgs']]]] = None):
|
|
4171
|
+
"""
|
|
4172
|
+
:param pulumi.Input[_builtins.bool] is_public: If true, connections from the interface to IPv6 addresses outside the VPC, and connections from IPv6 addresses outside the VPC to the interface will be permitted. (Default: `false`)
|
|
4173
|
+
|
|
4174
|
+
* `slaac` - (Optional) An array of SLAAC prefixes to use for this interface.
|
|
4175
|
+
|
|
4176
|
+
* `range` - (Optional) An array of IPv6 ranges to use for this interface.
|
|
4177
|
+
:param pulumi.Input[Sequence[pulumi.Input['InstanceInterfaceIpv6RangeArgs']]] ranges: A prefix to add to this interface, or `auto` for a new IPv6 prefix to be automatically allocated.
|
|
4178
|
+
:param pulumi.Input[Sequence[pulumi.Input['InstanceInterfaceIpv6SlaacArgs']]] slaacs: An array of SLAAC prefixes to use for this interface.
|
|
4179
|
+
"""
|
|
4180
|
+
if is_public is not None:
|
|
4181
|
+
pulumi.set(__self__, "is_public", is_public)
|
|
4182
|
+
if ranges is not None:
|
|
4183
|
+
pulumi.set(__self__, "ranges", ranges)
|
|
4184
|
+
if slaacs is not None:
|
|
4185
|
+
pulumi.set(__self__, "slaacs", slaacs)
|
|
4186
|
+
|
|
4187
|
+
@_builtins.property
|
|
4188
|
+
@pulumi.getter(name="isPublic")
|
|
4189
|
+
def is_public(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
4190
|
+
"""
|
|
4191
|
+
If true, connections from the interface to IPv6 addresses outside the VPC, and connections from IPv6 addresses outside the VPC to the interface will be permitted. (Default: `false`)
|
|
4192
|
+
|
|
4193
|
+
* `slaac` - (Optional) An array of SLAAC prefixes to use for this interface.
|
|
4194
|
+
|
|
4195
|
+
* `range` - (Optional) An array of IPv6 ranges to use for this interface.
|
|
4196
|
+
"""
|
|
4197
|
+
return pulumi.get(self, "is_public")
|
|
4198
|
+
|
|
4199
|
+
@is_public.setter
|
|
4200
|
+
def is_public(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
4201
|
+
pulumi.set(self, "is_public", value)
|
|
4202
|
+
|
|
4203
|
+
@_builtins.property
|
|
4204
|
+
@pulumi.getter
|
|
4205
|
+
def ranges(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['InstanceInterfaceIpv6RangeArgs']]]]:
|
|
4206
|
+
"""
|
|
4207
|
+
A prefix to add to this interface, or `auto` for a new IPv6 prefix to be automatically allocated.
|
|
4208
|
+
"""
|
|
4209
|
+
return pulumi.get(self, "ranges")
|
|
4210
|
+
|
|
4211
|
+
@ranges.setter
|
|
4212
|
+
def ranges(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceInterfaceIpv6RangeArgs']]]]):
|
|
4213
|
+
pulumi.set(self, "ranges", value)
|
|
4214
|
+
|
|
4215
|
+
@_builtins.property
|
|
4216
|
+
@pulumi.getter
|
|
4217
|
+
def slaacs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['InstanceInterfaceIpv6SlaacArgs']]]]:
|
|
4218
|
+
"""
|
|
4219
|
+
An array of SLAAC prefixes to use for this interface.
|
|
4220
|
+
"""
|
|
4221
|
+
return pulumi.get(self, "slaacs")
|
|
4222
|
+
|
|
4223
|
+
@slaacs.setter
|
|
4224
|
+
def slaacs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceInterfaceIpv6SlaacArgs']]]]):
|
|
4225
|
+
pulumi.set(self, "slaacs", value)
|
|
4226
|
+
|
|
4227
|
+
|
|
4228
|
+
if not MYPY:
|
|
4229
|
+
class InstanceInterfaceIpv6RangeArgsDict(TypedDict):
|
|
4230
|
+
assigned_range: NotRequired[pulumi.Input[_builtins.str]]
|
|
4231
|
+
"""
|
|
4232
|
+
The value of `range` computed by the API. This is necessary when needing to access the range implicitly allocated using `auto`.
|
|
4233
|
+
"""
|
|
4234
|
+
range: NotRequired[pulumi.Input[_builtins.str]]
|
|
4235
|
+
"""
|
|
4236
|
+
A prefix to add to this interface, or `auto` for a new IPv6 prefix to be automatically allocated.
|
|
4237
|
+
"""
|
|
4238
|
+
elif False:
|
|
4239
|
+
InstanceInterfaceIpv6RangeArgsDict: TypeAlias = Mapping[str, Any]
|
|
4240
|
+
|
|
4241
|
+
@pulumi.input_type
|
|
4242
|
+
class InstanceInterfaceIpv6RangeArgs:
|
|
4243
|
+
def __init__(__self__, *,
|
|
4244
|
+
assigned_range: Optional[pulumi.Input[_builtins.str]] = None,
|
|
4245
|
+
range: Optional[pulumi.Input[_builtins.str]] = None):
|
|
4246
|
+
"""
|
|
4247
|
+
:param pulumi.Input[_builtins.str] assigned_range: The value of `range` computed by the API. This is necessary when needing to access the range implicitly allocated using `auto`.
|
|
4248
|
+
:param pulumi.Input[_builtins.str] range: A prefix to add to this interface, or `auto` for a new IPv6 prefix to be automatically allocated.
|
|
4249
|
+
"""
|
|
4250
|
+
if assigned_range is not None:
|
|
4251
|
+
pulumi.set(__self__, "assigned_range", assigned_range)
|
|
4252
|
+
if range is not None:
|
|
4253
|
+
pulumi.set(__self__, "range", range)
|
|
4254
|
+
|
|
4255
|
+
@_builtins.property
|
|
4256
|
+
@pulumi.getter(name="assignedRange")
|
|
4257
|
+
def assigned_range(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
4258
|
+
"""
|
|
4259
|
+
The value of `range` computed by the API. This is necessary when needing to access the range implicitly allocated using `auto`.
|
|
4260
|
+
"""
|
|
4261
|
+
return pulumi.get(self, "assigned_range")
|
|
4262
|
+
|
|
4263
|
+
@assigned_range.setter
|
|
4264
|
+
def assigned_range(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
4265
|
+
pulumi.set(self, "assigned_range", value)
|
|
4266
|
+
|
|
4267
|
+
@_builtins.property
|
|
4268
|
+
@pulumi.getter
|
|
4269
|
+
def range(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
4270
|
+
"""
|
|
4271
|
+
A prefix to add to this interface, or `auto` for a new IPv6 prefix to be automatically allocated.
|
|
4272
|
+
"""
|
|
4273
|
+
return pulumi.get(self, "range")
|
|
4274
|
+
|
|
4275
|
+
@range.setter
|
|
4276
|
+
def range(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
4277
|
+
pulumi.set(self, "range", value)
|
|
4278
|
+
|
|
4279
|
+
|
|
4280
|
+
if not MYPY:
|
|
4281
|
+
class InstanceInterfaceIpv6SlaacArgsDict(TypedDict):
|
|
4282
|
+
address: NotRequired[pulumi.Input[_builtins.str]]
|
|
4283
|
+
"""
|
|
4284
|
+
The SLAAC address chosen for this interface.
|
|
4285
|
+
"""
|
|
4286
|
+
assigned_range: NotRequired[pulumi.Input[_builtins.str]]
|
|
4287
|
+
"""
|
|
4288
|
+
The value of `range` computed by the API. This is necessary when needing to access the range implicitly allocated using `auto`.
|
|
4289
|
+
"""
|
|
4290
|
+
range: NotRequired[pulumi.Input[_builtins.str]]
|
|
4291
|
+
"""
|
|
4292
|
+
A SLAAC prefix to add to this interface, or `auto` for a new IPv6 prefix to be automatically allocated.
|
|
4293
|
+
"""
|
|
4294
|
+
elif False:
|
|
4295
|
+
InstanceInterfaceIpv6SlaacArgsDict: TypeAlias = Mapping[str, Any]
|
|
4296
|
+
|
|
4297
|
+
@pulumi.input_type
|
|
4298
|
+
class InstanceInterfaceIpv6SlaacArgs:
|
|
4299
|
+
def __init__(__self__, *,
|
|
4300
|
+
address: Optional[pulumi.Input[_builtins.str]] = None,
|
|
4301
|
+
assigned_range: Optional[pulumi.Input[_builtins.str]] = None,
|
|
4302
|
+
range: Optional[pulumi.Input[_builtins.str]] = None):
|
|
4303
|
+
"""
|
|
4304
|
+
:param pulumi.Input[_builtins.str] address: The SLAAC address chosen for this interface.
|
|
4305
|
+
:param pulumi.Input[_builtins.str] assigned_range: The value of `range` computed by the API. This is necessary when needing to access the range implicitly allocated using `auto`.
|
|
4306
|
+
:param pulumi.Input[_builtins.str] range: A SLAAC prefix to add to this interface, or `auto` for a new IPv6 prefix to be automatically allocated.
|
|
4307
|
+
"""
|
|
4308
|
+
if address is not None:
|
|
4309
|
+
pulumi.set(__self__, "address", address)
|
|
4310
|
+
if assigned_range is not None:
|
|
4311
|
+
pulumi.set(__self__, "assigned_range", assigned_range)
|
|
4312
|
+
if range is not None:
|
|
4313
|
+
pulumi.set(__self__, "range", range)
|
|
4314
|
+
|
|
4315
|
+
@_builtins.property
|
|
4316
|
+
@pulumi.getter
|
|
4317
|
+
def address(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
4318
|
+
"""
|
|
4319
|
+
The SLAAC address chosen for this interface.
|
|
4320
|
+
"""
|
|
4321
|
+
return pulumi.get(self, "address")
|
|
4322
|
+
|
|
4323
|
+
@address.setter
|
|
4324
|
+
def address(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
4325
|
+
pulumi.set(self, "address", value)
|
|
4326
|
+
|
|
4327
|
+
@_builtins.property
|
|
4328
|
+
@pulumi.getter(name="assignedRange")
|
|
4329
|
+
def assigned_range(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
4330
|
+
"""
|
|
4331
|
+
The value of `range` computed by the API. This is necessary when needing to access the range implicitly allocated using `auto`.
|
|
4332
|
+
"""
|
|
4333
|
+
return pulumi.get(self, "assigned_range")
|
|
4334
|
+
|
|
4335
|
+
@assigned_range.setter
|
|
4336
|
+
def assigned_range(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
4337
|
+
pulumi.set(self, "assigned_range", value)
|
|
4338
|
+
|
|
4339
|
+
@_builtins.property
|
|
4340
|
+
@pulumi.getter
|
|
4341
|
+
def range(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
4342
|
+
"""
|
|
4343
|
+
A SLAAC prefix to add to this interface, or `auto` for a new IPv6 prefix to be automatically allocated.
|
|
4344
|
+
"""
|
|
4345
|
+
return pulumi.get(self, "range")
|
|
4346
|
+
|
|
4347
|
+
@range.setter
|
|
4348
|
+
def range(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
4349
|
+
pulumi.set(self, "range", value)
|
|
4350
|
+
|
|
4351
|
+
|
|
3718
4352
|
if not MYPY:
|
|
3719
4353
|
class InstanceIpVpcNat11ArgsDict(TypedDict):
|
|
3720
4354
|
address: pulumi.Input[_builtins.str]
|
|
@@ -4044,12 +4678,16 @@ if not MYPY:
|
|
|
4044
4678
|
"""
|
|
4045
4679
|
Defines the ACL configuration for an LKE cluster's control plane.
|
|
4046
4680
|
"""
|
|
4047
|
-
|
|
4681
|
+
audit_logs_enabled: NotRequired[pulumi.Input[_builtins.bool]]
|
|
4048
4682
|
"""
|
|
4049
|
-
|
|
4683
|
+
Enables audit logs on the cluster's control plane.
|
|
4050
4684
|
|
|
4051
4685
|
* `acl` - (Optional) Defines the ACL configuration for an LKE cluster's control plane.
|
|
4052
4686
|
"""
|
|
4687
|
+
high_availability: NotRequired[pulumi.Input[_builtins.bool]]
|
|
4688
|
+
"""
|
|
4689
|
+
Defines whether High Availability is enabled for the cluster Control Plane. This is an **irreversible** change.
|
|
4690
|
+
"""
|
|
4053
4691
|
elif False:
|
|
4054
4692
|
LkeClusterControlPlaneArgsDict: TypeAlias = Mapping[str, Any]
|
|
4055
4693
|
|
|
@@ -4057,15 +4695,19 @@ elif False:
|
|
|
4057
4695
|
class LkeClusterControlPlaneArgs:
|
|
4058
4696
|
def __init__(__self__, *,
|
|
4059
4697
|
acl: Optional[pulumi.Input['LkeClusterControlPlaneAclArgs']] = None,
|
|
4698
|
+
audit_logs_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
4060
4699
|
high_availability: Optional[pulumi.Input[_builtins.bool]] = None):
|
|
4061
4700
|
"""
|
|
4062
4701
|
:param pulumi.Input['LkeClusterControlPlaneAclArgs'] acl: Defines the ACL configuration for an LKE cluster's control plane.
|
|
4063
|
-
:param pulumi.Input[_builtins.bool]
|
|
4702
|
+
:param pulumi.Input[_builtins.bool] audit_logs_enabled: Enables audit logs on the cluster's control plane.
|
|
4064
4703
|
|
|
4065
4704
|
* `acl` - (Optional) Defines the ACL configuration for an LKE cluster's control plane.
|
|
4705
|
+
:param pulumi.Input[_builtins.bool] high_availability: Defines whether High Availability is enabled for the cluster Control Plane. This is an **irreversible** change.
|
|
4066
4706
|
"""
|
|
4067
4707
|
if acl is not None:
|
|
4068
4708
|
pulumi.set(__self__, "acl", acl)
|
|
4709
|
+
if audit_logs_enabled is not None:
|
|
4710
|
+
pulumi.set(__self__, "audit_logs_enabled", audit_logs_enabled)
|
|
4069
4711
|
if high_availability is not None:
|
|
4070
4712
|
pulumi.set(__self__, "high_availability", high_availability)
|
|
4071
4713
|
|
|
@@ -4081,13 +4723,25 @@ class LkeClusterControlPlaneArgs:
|
|
|
4081
4723
|
def acl(self, value: Optional[pulumi.Input['LkeClusterControlPlaneAclArgs']]):
|
|
4082
4724
|
pulumi.set(self, "acl", value)
|
|
4083
4725
|
|
|
4726
|
+
@_builtins.property
|
|
4727
|
+
@pulumi.getter(name="auditLogsEnabled")
|
|
4728
|
+
def audit_logs_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
4729
|
+
"""
|
|
4730
|
+
Enables audit logs on the cluster's control plane.
|
|
4731
|
+
|
|
4732
|
+
* `acl` - (Optional) Defines the ACL configuration for an LKE cluster's control plane.
|
|
4733
|
+
"""
|
|
4734
|
+
return pulumi.get(self, "audit_logs_enabled")
|
|
4735
|
+
|
|
4736
|
+
@audit_logs_enabled.setter
|
|
4737
|
+
def audit_logs_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
4738
|
+
pulumi.set(self, "audit_logs_enabled", value)
|
|
4739
|
+
|
|
4084
4740
|
@_builtins.property
|
|
4085
4741
|
@pulumi.getter(name="highAvailability")
|
|
4086
4742
|
def high_availability(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
4087
4743
|
"""
|
|
4088
4744
|
Defines whether High Availability is enabled for the cluster Control Plane. This is an **irreversible** change.
|
|
4089
|
-
|
|
4090
|
-
* `acl` - (Optional) Defines the ACL configuration for an LKE cluster's control plane.
|
|
4091
4745
|
"""
|
|
4092
4746
|
return pulumi.get(self, "high_availability")
|
|
4093
4747
|
|
|
@@ -5546,6 +6200,57 @@ class NodeBalancerTransferArgs:
|
|
|
5546
6200
|
pulumi.set(self, "total", value)
|
|
5547
6201
|
|
|
5548
6202
|
|
|
6203
|
+
if not MYPY:
|
|
6204
|
+
class NodeBalancerVpcArgsDict(TypedDict):
|
|
6205
|
+
subnet_id: pulumi.Input[_builtins.int]
|
|
6206
|
+
"""
|
|
6207
|
+
(Required) The ID of a subnet to assign to this NodeBalancer.
|
|
6208
|
+
"""
|
|
6209
|
+
ipv4_range: NotRequired[pulumi.Input[_builtins.str]]
|
|
6210
|
+
"""
|
|
6211
|
+
(Optional) A CIDR range for the VPC's IPv4 addresses. The NodeBalancer sources IP addresses from this range when routing traffic to the backend VPC nodes.
|
|
6212
|
+
"""
|
|
6213
|
+
elif False:
|
|
6214
|
+
NodeBalancerVpcArgsDict: TypeAlias = Mapping[str, Any]
|
|
6215
|
+
|
|
6216
|
+
@pulumi.input_type
|
|
6217
|
+
class NodeBalancerVpcArgs:
|
|
6218
|
+
def __init__(__self__, *,
|
|
6219
|
+
subnet_id: pulumi.Input[_builtins.int],
|
|
6220
|
+
ipv4_range: Optional[pulumi.Input[_builtins.str]] = None):
|
|
6221
|
+
"""
|
|
6222
|
+
:param pulumi.Input[_builtins.int] subnet_id: (Required) The ID of a subnet to assign to this NodeBalancer.
|
|
6223
|
+
:param pulumi.Input[_builtins.str] ipv4_range: (Optional) A CIDR range for the VPC's IPv4 addresses. The NodeBalancer sources IP addresses from this range when routing traffic to the backend VPC nodes.
|
|
6224
|
+
"""
|
|
6225
|
+
pulumi.set(__self__, "subnet_id", subnet_id)
|
|
6226
|
+
if ipv4_range is not None:
|
|
6227
|
+
pulumi.set(__self__, "ipv4_range", ipv4_range)
|
|
6228
|
+
|
|
6229
|
+
@_builtins.property
|
|
6230
|
+
@pulumi.getter(name="subnetId")
|
|
6231
|
+
def subnet_id(self) -> pulumi.Input[_builtins.int]:
|
|
6232
|
+
"""
|
|
6233
|
+
(Required) The ID of a subnet to assign to this NodeBalancer.
|
|
6234
|
+
"""
|
|
6235
|
+
return pulumi.get(self, "subnet_id")
|
|
6236
|
+
|
|
6237
|
+
@subnet_id.setter
|
|
6238
|
+
def subnet_id(self, value: pulumi.Input[_builtins.int]):
|
|
6239
|
+
pulumi.set(self, "subnet_id", value)
|
|
6240
|
+
|
|
6241
|
+
@_builtins.property
|
|
6242
|
+
@pulumi.getter(name="ipv4Range")
|
|
6243
|
+
def ipv4_range(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
6244
|
+
"""
|
|
6245
|
+
(Optional) A CIDR range for the VPC's IPv4 addresses. The NodeBalancer sources IP addresses from this range when routing traffic to the backend VPC nodes.
|
|
6246
|
+
"""
|
|
6247
|
+
return pulumi.get(self, "ipv4_range")
|
|
6248
|
+
|
|
6249
|
+
@ipv4_range.setter
|
|
6250
|
+
def ipv4_range(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
6251
|
+
pulumi.set(self, "ipv4_range", value)
|
|
6252
|
+
|
|
6253
|
+
|
|
5549
6254
|
if not MYPY:
|
|
5550
6255
|
class ObjectStorageBucketCertArgsDict(TypedDict):
|
|
5551
6256
|
certificate: pulumi.Input[_builtins.str]
|
|
@@ -6413,10 +7118,6 @@ if not MYPY:
|
|
|
6413
7118
|
"""
|
|
6414
7119
|
If true, this User may add NodeBalancers.
|
|
6415
7120
|
"""
|
|
6416
|
-
add_placement_groups: NotRequired[pulumi.Input[_builtins.bool]]
|
|
6417
|
-
"""
|
|
6418
|
-
If true, this User may add Placement Groups.
|
|
6419
|
-
"""
|
|
6420
7121
|
add_stackscripts: NotRequired[pulumi.Input[_builtins.bool]]
|
|
6421
7122
|
"""
|
|
6422
7123
|
If true, this User may add StackScripts.
|
|
@@ -6451,7 +7152,6 @@ class UserGlobalGrantsArgs:
|
|
|
6451
7152
|
add_linodes: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
6452
7153
|
add_longview: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
6453
7154
|
add_nodebalancers: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
6454
|
-
add_placement_groups: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
6455
7155
|
add_stackscripts: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
6456
7156
|
add_volumes: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
6457
7157
|
add_vpcs: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
@@ -6466,7 +7166,6 @@ class UserGlobalGrantsArgs:
|
|
|
6466
7166
|
:param pulumi.Input[_builtins.bool] add_linodes: If true, this User may create Linodes.
|
|
6467
7167
|
:param pulumi.Input[_builtins.bool] add_longview: If true, this User may create Longview clients and view the current plan.
|
|
6468
7168
|
:param pulumi.Input[_builtins.bool] add_nodebalancers: If true, this User may add NodeBalancers.
|
|
6469
|
-
:param pulumi.Input[_builtins.bool] add_placement_groups: If true, this User may add Placement Groups.
|
|
6470
7169
|
:param pulumi.Input[_builtins.bool] add_stackscripts: If true, this User may add StackScripts.
|
|
6471
7170
|
:param pulumi.Input[_builtins.bool] add_volumes: If true, this User may add Volumes.
|
|
6472
7171
|
:param pulumi.Input[_builtins.bool] add_vpcs: If true, this User may add Virtual Private Clouds (VPCs).
|
|
@@ -6489,8 +7188,6 @@ class UserGlobalGrantsArgs:
|
|
|
6489
7188
|
pulumi.set(__self__, "add_longview", add_longview)
|
|
6490
7189
|
if add_nodebalancers is not None:
|
|
6491
7190
|
pulumi.set(__self__, "add_nodebalancers", add_nodebalancers)
|
|
6492
|
-
if add_placement_groups is not None:
|
|
6493
|
-
pulumi.set(__self__, "add_placement_groups", add_placement_groups)
|
|
6494
7191
|
if add_stackscripts is not None:
|
|
6495
7192
|
pulumi.set(__self__, "add_stackscripts", add_stackscripts)
|
|
6496
7193
|
if add_volumes is not None:
|
|
@@ -6598,18 +7295,6 @@ class UserGlobalGrantsArgs:
|
|
|
6598
7295
|
def add_nodebalancers(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
6599
7296
|
pulumi.set(self, "add_nodebalancers", value)
|
|
6600
7297
|
|
|
6601
|
-
@_builtins.property
|
|
6602
|
-
@pulumi.getter(name="addPlacementGroups")
|
|
6603
|
-
def add_placement_groups(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
6604
|
-
"""
|
|
6605
|
-
If true, this User may add Placement Groups.
|
|
6606
|
-
"""
|
|
6607
|
-
return pulumi.get(self, "add_placement_groups")
|
|
6608
|
-
|
|
6609
|
-
@add_placement_groups.setter
|
|
6610
|
-
def add_placement_groups(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
6611
|
-
pulumi.set(self, "add_placement_groups", value)
|
|
6612
|
-
|
|
6613
7298
|
@_builtins.property
|
|
6614
7299
|
@pulumi.getter(name="addStackscripts")
|
|
6615
7300
|
def add_stackscripts(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
@@ -6871,56 +7556,6 @@ class UserNodebalancerGrantArgs:
|
|
|
6871
7556
|
pulumi.set(self, "permissions", value)
|
|
6872
7557
|
|
|
6873
7558
|
|
|
6874
|
-
if not MYPY:
|
|
6875
|
-
class UserPlacementGroupGrantArgsDict(TypedDict):
|
|
6876
|
-
id: pulumi.Input[_builtins.int]
|
|
6877
|
-
"""
|
|
6878
|
-
The ID of the entity this grant applies to.
|
|
6879
|
-
"""
|
|
6880
|
-
permissions: pulumi.Input[_builtins.str]
|
|
6881
|
-
"""
|
|
6882
|
-
The level of access this User has to this entity. If null, this User has no access.
|
|
6883
|
-
"""
|
|
6884
|
-
elif False:
|
|
6885
|
-
UserPlacementGroupGrantArgsDict: TypeAlias = Mapping[str, Any]
|
|
6886
|
-
|
|
6887
|
-
@pulumi.input_type
|
|
6888
|
-
class UserPlacementGroupGrantArgs:
|
|
6889
|
-
def __init__(__self__, *,
|
|
6890
|
-
id: pulumi.Input[_builtins.int],
|
|
6891
|
-
permissions: pulumi.Input[_builtins.str]):
|
|
6892
|
-
"""
|
|
6893
|
-
:param pulumi.Input[_builtins.int] id: The ID of the entity this grant applies to.
|
|
6894
|
-
:param pulumi.Input[_builtins.str] permissions: The level of access this User has to this entity. If null, this User has no access.
|
|
6895
|
-
"""
|
|
6896
|
-
pulumi.set(__self__, "id", id)
|
|
6897
|
-
pulumi.set(__self__, "permissions", permissions)
|
|
6898
|
-
|
|
6899
|
-
@_builtins.property
|
|
6900
|
-
@pulumi.getter
|
|
6901
|
-
def id(self) -> pulumi.Input[_builtins.int]:
|
|
6902
|
-
"""
|
|
6903
|
-
The ID of the entity this grant applies to.
|
|
6904
|
-
"""
|
|
6905
|
-
return pulumi.get(self, "id")
|
|
6906
|
-
|
|
6907
|
-
@id.setter
|
|
6908
|
-
def id(self, value: pulumi.Input[_builtins.int]):
|
|
6909
|
-
pulumi.set(self, "id", value)
|
|
6910
|
-
|
|
6911
|
-
@_builtins.property
|
|
6912
|
-
@pulumi.getter
|
|
6913
|
-
def permissions(self) -> pulumi.Input[_builtins.str]:
|
|
6914
|
-
"""
|
|
6915
|
-
The level of access this User has to this entity. If null, this User has no access.
|
|
6916
|
-
"""
|
|
6917
|
-
return pulumi.get(self, "permissions")
|
|
6918
|
-
|
|
6919
|
-
@permissions.setter
|
|
6920
|
-
def permissions(self, value: pulumi.Input[_builtins.str]):
|
|
6921
|
-
pulumi.set(self, "permissions", value)
|
|
6922
|
-
|
|
6923
|
-
|
|
6924
7559
|
if not MYPY:
|
|
6925
7560
|
class UserStackscriptGrantArgsDict(TypedDict):
|
|
6926
7561
|
id: pulumi.Input[_builtins.int]
|
|
@@ -7124,23 +7759,127 @@ class VolumeTimeoutsArgs:
|
|
|
7124
7759
|
"""
|
|
7125
7760
|
Used when deleting the volume
|
|
7126
7761
|
"""
|
|
7127
|
-
return pulumi.get(self, "delete")
|
|
7762
|
+
return pulumi.get(self, "delete")
|
|
7763
|
+
|
|
7764
|
+
@delete.setter
|
|
7765
|
+
def delete(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
7766
|
+
pulumi.set(self, "delete", value)
|
|
7767
|
+
|
|
7768
|
+
@_builtins.property
|
|
7769
|
+
@pulumi.getter
|
|
7770
|
+
def update(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
7771
|
+
"""
|
|
7772
|
+
Used when updating the volume when necessary during update - e.g. when resizing the volume
|
|
7773
|
+
"""
|
|
7774
|
+
return pulumi.get(self, "update")
|
|
7775
|
+
|
|
7776
|
+
@update.setter
|
|
7777
|
+
def update(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
7778
|
+
pulumi.set(self, "update", value)
|
|
7779
|
+
|
|
7780
|
+
|
|
7781
|
+
if not MYPY:
|
|
7782
|
+
class VpcIpv6ArgsDict(TypedDict):
|
|
7783
|
+
allocated_range: NotRequired[pulumi.Input[_builtins.str]]
|
|
7784
|
+
"""
|
|
7785
|
+
The IPv6 range assigned to this VPC.
|
|
7786
|
+
"""
|
|
7787
|
+
range: NotRequired[pulumi.Input[_builtins.str]]
|
|
7788
|
+
"""
|
|
7789
|
+
The IPv6 range assigned to this VPC.
|
|
7790
|
+
"""
|
|
7791
|
+
elif False:
|
|
7792
|
+
VpcIpv6ArgsDict: TypeAlias = Mapping[str, Any]
|
|
7793
|
+
|
|
7794
|
+
@pulumi.input_type
|
|
7795
|
+
class VpcIpv6Args:
|
|
7796
|
+
def __init__(__self__, *,
|
|
7797
|
+
allocated_range: Optional[pulumi.Input[_builtins.str]] = None,
|
|
7798
|
+
range: Optional[pulumi.Input[_builtins.str]] = None):
|
|
7799
|
+
"""
|
|
7800
|
+
:param pulumi.Input[_builtins.str] allocated_range: The IPv6 range assigned to this VPC.
|
|
7801
|
+
:param pulumi.Input[_builtins.str] range: The IPv6 range assigned to this VPC.
|
|
7802
|
+
"""
|
|
7803
|
+
if allocated_range is not None:
|
|
7804
|
+
pulumi.set(__self__, "allocated_range", allocated_range)
|
|
7805
|
+
if range is not None:
|
|
7806
|
+
pulumi.set(__self__, "range", range)
|
|
7807
|
+
|
|
7808
|
+
@_builtins.property
|
|
7809
|
+
@pulumi.getter(name="allocatedRange")
|
|
7810
|
+
def allocated_range(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
7811
|
+
"""
|
|
7812
|
+
The IPv6 range assigned to this VPC.
|
|
7813
|
+
"""
|
|
7814
|
+
return pulumi.get(self, "allocated_range")
|
|
7815
|
+
|
|
7816
|
+
@allocated_range.setter
|
|
7817
|
+
def allocated_range(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
7818
|
+
pulumi.set(self, "allocated_range", value)
|
|
7819
|
+
|
|
7820
|
+
@_builtins.property
|
|
7821
|
+
@pulumi.getter
|
|
7822
|
+
def range(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
7823
|
+
"""
|
|
7824
|
+
The IPv6 range assigned to this VPC.
|
|
7825
|
+
"""
|
|
7826
|
+
return pulumi.get(self, "range")
|
|
7827
|
+
|
|
7828
|
+
@range.setter
|
|
7829
|
+
def range(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
7830
|
+
pulumi.set(self, "range", value)
|
|
7831
|
+
|
|
7832
|
+
|
|
7833
|
+
if not MYPY:
|
|
7834
|
+
class VpcSubnetIpv6ArgsDict(TypedDict):
|
|
7835
|
+
allocated_range: NotRequired[pulumi.Input[_builtins.str]]
|
|
7836
|
+
"""
|
|
7837
|
+
The IPv6 range assigned to this subnet.
|
|
7838
|
+
"""
|
|
7839
|
+
range: NotRequired[pulumi.Input[_builtins.str]]
|
|
7840
|
+
"""
|
|
7841
|
+
An existing IPv6 prefix owned by the current account or a forward slash (/) followed by a valid prefix length. If unspecified, a range with the default prefix will be allocated for this VPC.
|
|
7842
|
+
"""
|
|
7843
|
+
elif False:
|
|
7844
|
+
VpcSubnetIpv6ArgsDict: TypeAlias = Mapping[str, Any]
|
|
7845
|
+
|
|
7846
|
+
@pulumi.input_type
|
|
7847
|
+
class VpcSubnetIpv6Args:
|
|
7848
|
+
def __init__(__self__, *,
|
|
7849
|
+
allocated_range: Optional[pulumi.Input[_builtins.str]] = None,
|
|
7850
|
+
range: Optional[pulumi.Input[_builtins.str]] = None):
|
|
7851
|
+
"""
|
|
7852
|
+
:param pulumi.Input[_builtins.str] allocated_range: The IPv6 range assigned to this subnet.
|
|
7853
|
+
:param pulumi.Input[_builtins.str] range: An existing IPv6 prefix owned by the current account or a forward slash (/) followed by a valid prefix length. If unspecified, a range with the default prefix will be allocated for this VPC.
|
|
7854
|
+
"""
|
|
7855
|
+
if allocated_range is not None:
|
|
7856
|
+
pulumi.set(__self__, "allocated_range", allocated_range)
|
|
7857
|
+
if range is not None:
|
|
7858
|
+
pulumi.set(__self__, "range", range)
|
|
7859
|
+
|
|
7860
|
+
@_builtins.property
|
|
7861
|
+
@pulumi.getter(name="allocatedRange")
|
|
7862
|
+
def allocated_range(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
7863
|
+
"""
|
|
7864
|
+
The IPv6 range assigned to this subnet.
|
|
7865
|
+
"""
|
|
7866
|
+
return pulumi.get(self, "allocated_range")
|
|
7128
7867
|
|
|
7129
|
-
@
|
|
7130
|
-
def
|
|
7131
|
-
pulumi.set(self, "
|
|
7868
|
+
@allocated_range.setter
|
|
7869
|
+
def allocated_range(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
7870
|
+
pulumi.set(self, "allocated_range", value)
|
|
7132
7871
|
|
|
7133
7872
|
@_builtins.property
|
|
7134
7873
|
@pulumi.getter
|
|
7135
|
-
def
|
|
7874
|
+
def range(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
7136
7875
|
"""
|
|
7137
|
-
|
|
7876
|
+
An existing IPv6 prefix owned by the current account or a forward slash (/) followed by a valid prefix length. If unspecified, a range with the default prefix will be allocated for this VPC.
|
|
7138
7877
|
"""
|
|
7139
|
-
return pulumi.get(self, "
|
|
7878
|
+
return pulumi.get(self, "range")
|
|
7140
7879
|
|
|
7141
|
-
@
|
|
7142
|
-
def
|
|
7143
|
-
pulumi.set(self, "
|
|
7880
|
+
@range.setter
|
|
7881
|
+
def range(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
7882
|
+
pulumi.set(self, "range", value)
|
|
7144
7883
|
|
|
7145
7884
|
|
|
7146
7885
|
if not MYPY:
|
|
@@ -8359,6 +9098,10 @@ if not MYPY:
|
|
|
8359
9098
|
"""
|
|
8360
9099
|
A unique, user-defined string referring to the Managed Database.
|
|
8361
9100
|
"""
|
|
9101
|
+
private_network: 'GetDatabasesDatabasePrivateNetworkArgsDict'
|
|
9102
|
+
"""
|
|
9103
|
+
Restricts access to this database using a virtual private cloud (VPC) that you've configured in the region where the database will live.
|
|
9104
|
+
"""
|
|
8362
9105
|
region: _builtins.str
|
|
8363
9106
|
"""
|
|
8364
9107
|
The region to use for the Managed Database.
|
|
@@ -8403,6 +9146,7 @@ class GetDatabasesDatabaseArgs:
|
|
|
8403
9146
|
id: _builtins.int,
|
|
8404
9147
|
instance_uri: _builtins.str,
|
|
8405
9148
|
label: _builtins.str,
|
|
9149
|
+
private_network: 'GetDatabasesDatabasePrivateNetworkArgs',
|
|
8406
9150
|
region: _builtins.str,
|
|
8407
9151
|
replication_type: _builtins.str,
|
|
8408
9152
|
ssl_connection: _builtins.bool,
|
|
@@ -8421,6 +9165,7 @@ class GetDatabasesDatabaseArgs:
|
|
|
8421
9165
|
:param _builtins.int id: The ID of the Managed Database.
|
|
8422
9166
|
:param _builtins.str instance_uri: he API route for the database instance.
|
|
8423
9167
|
:param _builtins.str label: A unique, user-defined string referring to the Managed Database.
|
|
9168
|
+
:param 'GetDatabasesDatabasePrivateNetworkArgs' private_network: Restricts access to this database using a virtual private cloud (VPC) that you've configured in the region where the database will live.
|
|
8424
9169
|
:param _builtins.str region: The region to use for the Managed Database.
|
|
8425
9170
|
:param _builtins.str replication_type: The replication method used for the Managed Database.
|
|
8426
9171
|
:param _builtins.bool ssl_connection: Whether to require SSL credentials to establish a connection to the Managed Database.
|
|
@@ -8439,6 +9184,7 @@ class GetDatabasesDatabaseArgs:
|
|
|
8439
9184
|
pulumi.set(__self__, "id", id)
|
|
8440
9185
|
pulumi.set(__self__, "instance_uri", instance_uri)
|
|
8441
9186
|
pulumi.set(__self__, "label", label)
|
|
9187
|
+
pulumi.set(__self__, "private_network", private_network)
|
|
8442
9188
|
pulumi.set(__self__, "region", region)
|
|
8443
9189
|
pulumi.set(__self__, "replication_type", replication_type)
|
|
8444
9190
|
pulumi.set(__self__, "ssl_connection", ssl_connection)
|
|
@@ -8567,6 +9313,18 @@ class GetDatabasesDatabaseArgs:
|
|
|
8567
9313
|
def label(self, value: _builtins.str):
|
|
8568
9314
|
pulumi.set(self, "label", value)
|
|
8569
9315
|
|
|
9316
|
+
@_builtins.property
|
|
9317
|
+
@pulumi.getter(name="privateNetwork")
|
|
9318
|
+
def private_network(self) -> 'GetDatabasesDatabasePrivateNetworkArgs':
|
|
9319
|
+
"""
|
|
9320
|
+
Restricts access to this database using a virtual private cloud (VPC) that you've configured in the region where the database will live.
|
|
9321
|
+
"""
|
|
9322
|
+
return pulumi.get(self, "private_network")
|
|
9323
|
+
|
|
9324
|
+
@private_network.setter
|
|
9325
|
+
def private_network(self, value: 'GetDatabasesDatabasePrivateNetworkArgs'):
|
|
9326
|
+
pulumi.set(self, "private_network", value)
|
|
9327
|
+
|
|
8570
9328
|
@_builtins.property
|
|
8571
9329
|
@pulumi.getter
|
|
8572
9330
|
def region(self) -> _builtins.str:
|
|
@@ -8652,6 +9410,75 @@ class GetDatabasesDatabaseArgs:
|
|
|
8652
9410
|
pulumi.set(self, "version", value)
|
|
8653
9411
|
|
|
8654
9412
|
|
|
9413
|
+
if not MYPY:
|
|
9414
|
+
class GetDatabasesDatabasePrivateNetworkArgsDict(TypedDict):
|
|
9415
|
+
public_access: _builtins.bool
|
|
9416
|
+
"""
|
|
9417
|
+
If true, clients outside of the VPC can connect to the database using a public IP address.
|
|
9418
|
+
"""
|
|
9419
|
+
subnet_id: _builtins.int
|
|
9420
|
+
"""
|
|
9421
|
+
The ID of the VPC subnet to restrict access to this database using.
|
|
9422
|
+
"""
|
|
9423
|
+
vpc_id: _builtins.int
|
|
9424
|
+
"""
|
|
9425
|
+
The ID of the virtual private cloud (VPC) to restrict access to this database using.
|
|
9426
|
+
"""
|
|
9427
|
+
elif False:
|
|
9428
|
+
GetDatabasesDatabasePrivateNetworkArgsDict: TypeAlias = Mapping[str, Any]
|
|
9429
|
+
|
|
9430
|
+
@pulumi.input_type
|
|
9431
|
+
class GetDatabasesDatabasePrivateNetworkArgs:
|
|
9432
|
+
def __init__(__self__, *,
|
|
9433
|
+
public_access: _builtins.bool,
|
|
9434
|
+
subnet_id: _builtins.int,
|
|
9435
|
+
vpc_id: _builtins.int):
|
|
9436
|
+
"""
|
|
9437
|
+
:param _builtins.bool public_access: If true, clients outside of the VPC can connect to the database using a public IP address.
|
|
9438
|
+
:param _builtins.int subnet_id: The ID of the VPC subnet to restrict access to this database using.
|
|
9439
|
+
:param _builtins.int vpc_id: The ID of the virtual private cloud (VPC) to restrict access to this database using.
|
|
9440
|
+
"""
|
|
9441
|
+
pulumi.set(__self__, "public_access", public_access)
|
|
9442
|
+
pulumi.set(__self__, "subnet_id", subnet_id)
|
|
9443
|
+
pulumi.set(__self__, "vpc_id", vpc_id)
|
|
9444
|
+
|
|
9445
|
+
@_builtins.property
|
|
9446
|
+
@pulumi.getter(name="publicAccess")
|
|
9447
|
+
def public_access(self) -> _builtins.bool:
|
|
9448
|
+
"""
|
|
9449
|
+
If true, clients outside of the VPC can connect to the database using a public IP address.
|
|
9450
|
+
"""
|
|
9451
|
+
return pulumi.get(self, "public_access")
|
|
9452
|
+
|
|
9453
|
+
@public_access.setter
|
|
9454
|
+
def public_access(self, value: _builtins.bool):
|
|
9455
|
+
pulumi.set(self, "public_access", value)
|
|
9456
|
+
|
|
9457
|
+
@_builtins.property
|
|
9458
|
+
@pulumi.getter(name="subnetId")
|
|
9459
|
+
def subnet_id(self) -> _builtins.int:
|
|
9460
|
+
"""
|
|
9461
|
+
The ID of the VPC subnet to restrict access to this database using.
|
|
9462
|
+
"""
|
|
9463
|
+
return pulumi.get(self, "subnet_id")
|
|
9464
|
+
|
|
9465
|
+
@subnet_id.setter
|
|
9466
|
+
def subnet_id(self, value: _builtins.int):
|
|
9467
|
+
pulumi.set(self, "subnet_id", value)
|
|
9468
|
+
|
|
9469
|
+
@_builtins.property
|
|
9470
|
+
@pulumi.getter(name="vpcId")
|
|
9471
|
+
def vpc_id(self) -> _builtins.int:
|
|
9472
|
+
"""
|
|
9473
|
+
The ID of the virtual private cloud (VPC) to restrict access to this database using.
|
|
9474
|
+
"""
|
|
9475
|
+
return pulumi.get(self, "vpc_id")
|
|
9476
|
+
|
|
9477
|
+
@vpc_id.setter
|
|
9478
|
+
def vpc_id(self, value: _builtins.int):
|
|
9479
|
+
pulumi.set(self, "vpc_id", value)
|
|
9480
|
+
|
|
9481
|
+
|
|
8655
9482
|
if not MYPY:
|
|
8656
9483
|
class GetDatabasesFilterArgsDict(TypedDict):
|
|
8657
9484
|
name: _builtins.str
|
|
@@ -11328,6 +12155,10 @@ class GetKernelsKernelArgs:
|
|
|
11328
12155
|
|
|
11329
12156
|
if not MYPY:
|
|
11330
12157
|
class GetLkeClusterControlPlaneArgsDict(TypedDict):
|
|
12158
|
+
audit_logs_enabled: _builtins.bool
|
|
12159
|
+
"""
|
|
12160
|
+
Enables audit logs on the cluster's control plane.
|
|
12161
|
+
"""
|
|
11331
12162
|
high_availability: _builtins.bool
|
|
11332
12163
|
"""
|
|
11333
12164
|
Whether High Availability is enabled for the cluster Control Plane.
|
|
@@ -11342,16 +12173,31 @@ elif False:
|
|
|
11342
12173
|
@pulumi.input_type
|
|
11343
12174
|
class GetLkeClusterControlPlaneArgs:
|
|
11344
12175
|
def __init__(__self__, *,
|
|
12176
|
+
audit_logs_enabled: _builtins.bool,
|
|
11345
12177
|
high_availability: _builtins.bool,
|
|
11346
12178
|
acls: Optional[Sequence['GetLkeClusterControlPlaneAclArgs']] = None):
|
|
11347
12179
|
"""
|
|
12180
|
+
:param _builtins.bool audit_logs_enabled: Enables audit logs on the cluster's control plane.
|
|
11348
12181
|
:param _builtins.bool high_availability: Whether High Availability is enabled for the cluster Control Plane.
|
|
11349
12182
|
:param Sequence['GetLkeClusterControlPlaneAclArgs'] acls: The ACL configuration for an LKE cluster's control plane.
|
|
11350
12183
|
"""
|
|
12184
|
+
pulumi.set(__self__, "audit_logs_enabled", audit_logs_enabled)
|
|
11351
12185
|
pulumi.set(__self__, "high_availability", high_availability)
|
|
11352
12186
|
if acls is not None:
|
|
11353
12187
|
pulumi.set(__self__, "acls", acls)
|
|
11354
12188
|
|
|
12189
|
+
@_builtins.property
|
|
12190
|
+
@pulumi.getter(name="auditLogsEnabled")
|
|
12191
|
+
def audit_logs_enabled(self) -> _builtins.bool:
|
|
12192
|
+
"""
|
|
12193
|
+
Enables audit logs on the cluster's control plane.
|
|
12194
|
+
"""
|
|
12195
|
+
return pulumi.get(self, "audit_logs_enabled")
|
|
12196
|
+
|
|
12197
|
+
@audit_logs_enabled.setter
|
|
12198
|
+
def audit_logs_enabled(self, value: _builtins.bool):
|
|
12199
|
+
pulumi.set(self, "audit_logs_enabled", value)
|
|
12200
|
+
|
|
11355
12201
|
@_builtins.property
|
|
11356
12202
|
@pulumi.getter(name="highAvailability")
|
|
11357
12203
|
def high_availability(self) -> _builtins.bool:
|
|
@@ -12094,10 +12940,18 @@ if not MYPY:
|
|
|
12094
12940
|
"""
|
|
12095
12941
|
This Kubernetes cluster's location.
|
|
12096
12942
|
"""
|
|
12943
|
+
stack_type: _builtins.str
|
|
12944
|
+
"""
|
|
12945
|
+
The networking stack type of the Kubernetes cluster.
|
|
12946
|
+
"""
|
|
12097
12947
|
status: _builtins.str
|
|
12098
12948
|
"""
|
|
12099
12949
|
The status of the cluster.
|
|
12100
12950
|
"""
|
|
12951
|
+
subnet_id: _builtins.int
|
|
12952
|
+
"""
|
|
12953
|
+
The ID of the VPC subnet to use for the Kubernetes cluster. This subnet must be dual stack (IPv4 and IPv6 should both be enabled).
|
|
12954
|
+
"""
|
|
12101
12955
|
tags: Sequence[_builtins.str]
|
|
12102
12956
|
"""
|
|
12103
12957
|
An array of tags applied to this object. Tags are case-insensitive and are for organizational purposes only.
|
|
@@ -12110,6 +12964,10 @@ if not MYPY:
|
|
|
12110
12964
|
"""
|
|
12111
12965
|
When this Kubernetes cluster was updated.
|
|
12112
12966
|
"""
|
|
12967
|
+
vpc_id: _builtins.int
|
|
12968
|
+
"""
|
|
12969
|
+
The ID of the VPC to use for the Kubernetes cluster.
|
|
12970
|
+
"""
|
|
12113
12971
|
control_plane: NotRequired['GetLkeClustersLkeClusterControlPlaneArgsDict']
|
|
12114
12972
|
"""
|
|
12115
12973
|
Defines settings for the Kubernetes Control Plane.
|
|
@@ -12126,10 +12984,13 @@ class GetLkeClustersLkeClusterArgs:
|
|
|
12126
12984
|
k8s_version: _builtins.str,
|
|
12127
12985
|
label: _builtins.str,
|
|
12128
12986
|
region: _builtins.str,
|
|
12987
|
+
stack_type: _builtins.str,
|
|
12129
12988
|
status: _builtins.str,
|
|
12989
|
+
subnet_id: _builtins.int,
|
|
12130
12990
|
tags: Sequence[_builtins.str],
|
|
12131
12991
|
tier: _builtins.str,
|
|
12132
12992
|
updated: _builtins.str,
|
|
12993
|
+
vpc_id: _builtins.int,
|
|
12133
12994
|
control_plane: Optional['GetLkeClustersLkeClusterControlPlaneArgs'] = None):
|
|
12134
12995
|
"""
|
|
12135
12996
|
:param _builtins.bool apl_enabled: Enables the App Platform Layer for this cluster. Note: v4beta only and may not currently be available to all users.
|
|
@@ -12138,10 +12999,13 @@ class GetLkeClustersLkeClusterArgs:
|
|
|
12138
12999
|
:param _builtins.str k8s_version: The Kubernetes version for this Kubernetes cluster in the format of `major.minor` (e.g. `1.17`).
|
|
12139
13000
|
:param _builtins.str label: The unique label for the cluster.
|
|
12140
13001
|
:param _builtins.str region: This Kubernetes cluster's location.
|
|
13002
|
+
:param _builtins.str stack_type: The networking stack type of the Kubernetes cluster.
|
|
12141
13003
|
:param _builtins.str status: The status of the cluster.
|
|
13004
|
+
:param _builtins.int subnet_id: The ID of the VPC subnet to use for the Kubernetes cluster. This subnet must be dual stack (IPv4 and IPv6 should both be enabled).
|
|
12142
13005
|
:param Sequence[_builtins.str] tags: An array of tags applied to this object. Tags are case-insensitive and are for organizational purposes only.
|
|
12143
13006
|
:param _builtins.str tier: The desired Kubernetes tier. (**Note: v4beta only and may not currently be available to all users.**)
|
|
12144
13007
|
:param _builtins.str updated: When this Kubernetes cluster was updated.
|
|
13008
|
+
:param _builtins.int vpc_id: The ID of the VPC to use for the Kubernetes cluster.
|
|
12145
13009
|
:param 'GetLkeClustersLkeClusterControlPlaneArgs' control_plane: Defines settings for the Kubernetes Control Plane.
|
|
12146
13010
|
"""
|
|
12147
13011
|
pulumi.set(__self__, "apl_enabled", apl_enabled)
|
|
@@ -12150,10 +13014,13 @@ class GetLkeClustersLkeClusterArgs:
|
|
|
12150
13014
|
pulumi.set(__self__, "k8s_version", k8s_version)
|
|
12151
13015
|
pulumi.set(__self__, "label", label)
|
|
12152
13016
|
pulumi.set(__self__, "region", region)
|
|
13017
|
+
pulumi.set(__self__, "stack_type", stack_type)
|
|
12153
13018
|
pulumi.set(__self__, "status", status)
|
|
13019
|
+
pulumi.set(__self__, "subnet_id", subnet_id)
|
|
12154
13020
|
pulumi.set(__self__, "tags", tags)
|
|
12155
13021
|
pulumi.set(__self__, "tier", tier)
|
|
12156
13022
|
pulumi.set(__self__, "updated", updated)
|
|
13023
|
+
pulumi.set(__self__, "vpc_id", vpc_id)
|
|
12157
13024
|
if control_plane is not None:
|
|
12158
13025
|
pulumi.set(__self__, "control_plane", control_plane)
|
|
12159
13026
|
|
|
@@ -12229,6 +13096,18 @@ class GetLkeClustersLkeClusterArgs:
|
|
|
12229
13096
|
def region(self, value: _builtins.str):
|
|
12230
13097
|
pulumi.set(self, "region", value)
|
|
12231
13098
|
|
|
13099
|
+
@_builtins.property
|
|
13100
|
+
@pulumi.getter(name="stackType")
|
|
13101
|
+
def stack_type(self) -> _builtins.str:
|
|
13102
|
+
"""
|
|
13103
|
+
The networking stack type of the Kubernetes cluster.
|
|
13104
|
+
"""
|
|
13105
|
+
return pulumi.get(self, "stack_type")
|
|
13106
|
+
|
|
13107
|
+
@stack_type.setter
|
|
13108
|
+
def stack_type(self, value: _builtins.str):
|
|
13109
|
+
pulumi.set(self, "stack_type", value)
|
|
13110
|
+
|
|
12232
13111
|
@_builtins.property
|
|
12233
13112
|
@pulumi.getter
|
|
12234
13113
|
def status(self) -> _builtins.str:
|
|
@@ -12241,6 +13120,18 @@ class GetLkeClustersLkeClusterArgs:
|
|
|
12241
13120
|
def status(self, value: _builtins.str):
|
|
12242
13121
|
pulumi.set(self, "status", value)
|
|
12243
13122
|
|
|
13123
|
+
@_builtins.property
|
|
13124
|
+
@pulumi.getter(name="subnetId")
|
|
13125
|
+
def subnet_id(self) -> _builtins.int:
|
|
13126
|
+
"""
|
|
13127
|
+
The ID of the VPC subnet to use for the Kubernetes cluster. This subnet must be dual stack (IPv4 and IPv6 should both be enabled).
|
|
13128
|
+
"""
|
|
13129
|
+
return pulumi.get(self, "subnet_id")
|
|
13130
|
+
|
|
13131
|
+
@subnet_id.setter
|
|
13132
|
+
def subnet_id(self, value: _builtins.int):
|
|
13133
|
+
pulumi.set(self, "subnet_id", value)
|
|
13134
|
+
|
|
12244
13135
|
@_builtins.property
|
|
12245
13136
|
@pulumi.getter
|
|
12246
13137
|
def tags(self) -> Sequence[_builtins.str]:
|
|
@@ -12277,6 +13168,18 @@ class GetLkeClustersLkeClusterArgs:
|
|
|
12277
13168
|
def updated(self, value: _builtins.str):
|
|
12278
13169
|
pulumi.set(self, "updated", value)
|
|
12279
13170
|
|
|
13171
|
+
@_builtins.property
|
|
13172
|
+
@pulumi.getter(name="vpcId")
|
|
13173
|
+
def vpc_id(self) -> _builtins.int:
|
|
13174
|
+
"""
|
|
13175
|
+
The ID of the VPC to use for the Kubernetes cluster.
|
|
13176
|
+
"""
|
|
13177
|
+
return pulumi.get(self, "vpc_id")
|
|
13178
|
+
|
|
13179
|
+
@vpc_id.setter
|
|
13180
|
+
def vpc_id(self, value: _builtins.int):
|
|
13181
|
+
pulumi.set(self, "vpc_id", value)
|
|
13182
|
+
|
|
12280
13183
|
@_builtins.property
|
|
12281
13184
|
@pulumi.getter(name="controlPlane")
|
|
12282
13185
|
def control_plane(self) -> Optional['GetLkeClustersLkeClusterControlPlaneArgs']:
|
|
@@ -12292,6 +13195,10 @@ class GetLkeClustersLkeClusterArgs:
|
|
|
12292
13195
|
|
|
12293
13196
|
if not MYPY:
|
|
12294
13197
|
class GetLkeClustersLkeClusterControlPlaneArgsDict(TypedDict):
|
|
13198
|
+
audit_logs_enabled: _builtins.bool
|
|
13199
|
+
"""
|
|
13200
|
+
Enables audit logs on the cluster's control plane.
|
|
13201
|
+
"""
|
|
12295
13202
|
high_availability: _builtins.bool
|
|
12296
13203
|
"""
|
|
12297
13204
|
Whether High Availability is enabled for the cluster Control Plane.
|
|
@@ -12302,12 +13209,27 @@ elif False:
|
|
|
12302
13209
|
@pulumi.input_type
|
|
12303
13210
|
class GetLkeClustersLkeClusterControlPlaneArgs:
|
|
12304
13211
|
def __init__(__self__, *,
|
|
13212
|
+
audit_logs_enabled: _builtins.bool,
|
|
12305
13213
|
high_availability: _builtins.bool):
|
|
12306
13214
|
"""
|
|
13215
|
+
:param _builtins.bool audit_logs_enabled: Enables audit logs on the cluster's control plane.
|
|
12307
13216
|
:param _builtins.bool high_availability: Whether High Availability is enabled for the cluster Control Plane.
|
|
12308
13217
|
"""
|
|
13218
|
+
pulumi.set(__self__, "audit_logs_enabled", audit_logs_enabled)
|
|
12309
13219
|
pulumi.set(__self__, "high_availability", high_availability)
|
|
12310
13220
|
|
|
13221
|
+
@_builtins.property
|
|
13222
|
+
@pulumi.getter(name="auditLogsEnabled")
|
|
13223
|
+
def audit_logs_enabled(self) -> _builtins.bool:
|
|
13224
|
+
"""
|
|
13225
|
+
Enables audit logs on the cluster's control plane.
|
|
13226
|
+
"""
|
|
13227
|
+
return pulumi.get(self, "audit_logs_enabled")
|
|
13228
|
+
|
|
13229
|
+
@audit_logs_enabled.setter
|
|
13230
|
+
def audit_logs_enabled(self, value: _builtins.bool):
|
|
13231
|
+
pulumi.set(self, "audit_logs_enabled", value)
|
|
13232
|
+
|
|
12311
13233
|
@_builtins.property
|
|
12312
13234
|
@pulumi.getter(name="highAvailability")
|
|
12313
13235
|
def high_availability(self) -> _builtins.bool:
|
|
@@ -14722,6 +15644,76 @@ class GetNodebalancerConfigsNodebalancerConfigNodeStatusArgs:
|
|
|
14722
15644
|
pulumi.set(self, "up", value)
|
|
14723
15645
|
|
|
14724
15646
|
|
|
15647
|
+
if not MYPY:
|
|
15648
|
+
class GetNodebalancerVpcsFilterArgsDict(TypedDict):
|
|
15649
|
+
name: _builtins.str
|
|
15650
|
+
"""
|
|
15651
|
+
The name of the field to filter by. See the Filterable Fields section for a complete list of filterable fields.
|
|
15652
|
+
"""
|
|
15653
|
+
values: Sequence[_builtins.str]
|
|
15654
|
+
"""
|
|
15655
|
+
A list of values for the filter to allow. These values should all be in string form.
|
|
15656
|
+
"""
|
|
15657
|
+
match_by: NotRequired[_builtins.str]
|
|
15658
|
+
"""
|
|
15659
|
+
The method to match the field by. (`exact`, `regex`, `substring`; default `exact`)
|
|
15660
|
+
"""
|
|
15661
|
+
elif False:
|
|
15662
|
+
GetNodebalancerVpcsFilterArgsDict: TypeAlias = Mapping[str, Any]
|
|
15663
|
+
|
|
15664
|
+
@pulumi.input_type
|
|
15665
|
+
class GetNodebalancerVpcsFilterArgs:
|
|
15666
|
+
def __init__(__self__, *,
|
|
15667
|
+
name: _builtins.str,
|
|
15668
|
+
values: Sequence[_builtins.str],
|
|
15669
|
+
match_by: Optional[_builtins.str] = None):
|
|
15670
|
+
"""
|
|
15671
|
+
:param _builtins.str name: The name of the field to filter by. See the Filterable Fields section for a complete list of filterable fields.
|
|
15672
|
+
:param Sequence[_builtins.str] values: A list of values for the filter to allow. These values should all be in string form.
|
|
15673
|
+
:param _builtins.str match_by: The method to match the field by. (`exact`, `regex`, `substring`; default `exact`)
|
|
15674
|
+
"""
|
|
15675
|
+
pulumi.set(__self__, "name", name)
|
|
15676
|
+
pulumi.set(__self__, "values", values)
|
|
15677
|
+
if match_by is not None:
|
|
15678
|
+
pulumi.set(__self__, "match_by", match_by)
|
|
15679
|
+
|
|
15680
|
+
@_builtins.property
|
|
15681
|
+
@pulumi.getter
|
|
15682
|
+
def name(self) -> _builtins.str:
|
|
15683
|
+
"""
|
|
15684
|
+
The name of the field to filter by. See the Filterable Fields section for a complete list of filterable fields.
|
|
15685
|
+
"""
|
|
15686
|
+
return pulumi.get(self, "name")
|
|
15687
|
+
|
|
15688
|
+
@name.setter
|
|
15689
|
+
def name(self, value: _builtins.str):
|
|
15690
|
+
pulumi.set(self, "name", value)
|
|
15691
|
+
|
|
15692
|
+
@_builtins.property
|
|
15693
|
+
@pulumi.getter
|
|
15694
|
+
def values(self) -> Sequence[_builtins.str]:
|
|
15695
|
+
"""
|
|
15696
|
+
A list of values for the filter to allow. These values should all be in string form.
|
|
15697
|
+
"""
|
|
15698
|
+
return pulumi.get(self, "values")
|
|
15699
|
+
|
|
15700
|
+
@values.setter
|
|
15701
|
+
def values(self, value: Sequence[_builtins.str]):
|
|
15702
|
+
pulumi.set(self, "values", value)
|
|
15703
|
+
|
|
15704
|
+
@_builtins.property
|
|
15705
|
+
@pulumi.getter(name="matchBy")
|
|
15706
|
+
def match_by(self) -> Optional[_builtins.str]:
|
|
15707
|
+
"""
|
|
15708
|
+
The method to match the field by. (`exact`, `regex`, `substring`; default `exact`)
|
|
15709
|
+
"""
|
|
15710
|
+
return pulumi.get(self, "match_by")
|
|
15711
|
+
|
|
15712
|
+
@match_by.setter
|
|
15713
|
+
def match_by(self, value: Optional[_builtins.str]):
|
|
15714
|
+
pulumi.set(self, "match_by", value)
|
|
15715
|
+
|
|
15716
|
+
|
|
14725
15717
|
if not MYPY:
|
|
14726
15718
|
class GetNodebalancersFilterArgsDict(TypedDict):
|
|
14727
15719
|
name: _builtins.str
|
|
@@ -17003,100 +17995,31 @@ class GetStackScriptsStackscriptUserDefinedFieldArgs:
|
|
|
17003
17995
|
|
|
17004
17996
|
@_builtins.property
|
|
17005
17997
|
@pulumi.getter
|
|
17006
|
-
def name(self) -> _builtins.str:
|
|
17007
|
-
"""
|
|
17008
|
-
The name of the field.
|
|
17009
|
-
"""
|
|
17010
|
-
return pulumi.get(self, "name")
|
|
17011
|
-
|
|
17012
|
-
@name.setter
|
|
17013
|
-
def name(self, value: _builtins.str):
|
|
17014
|
-
pulumi.set(self, "name", value)
|
|
17015
|
-
|
|
17016
|
-
@_builtins.property
|
|
17017
|
-
@pulumi.getter(name="oneOf")
|
|
17018
|
-
def one_of(self) -> _builtins.str:
|
|
17019
|
-
"""
|
|
17020
|
-
A list of acceptable single values for the field.
|
|
17021
|
-
"""
|
|
17022
|
-
return pulumi.get(self, "one_of")
|
|
17023
|
-
|
|
17024
|
-
@one_of.setter
|
|
17025
|
-
def one_of(self, value: _builtins.str):
|
|
17026
|
-
pulumi.set(self, "one_of", value)
|
|
17027
|
-
|
|
17028
|
-
|
|
17029
|
-
if not MYPY:
|
|
17030
|
-
class GetUserDatabaseGrantArgsDict(TypedDict):
|
|
17031
|
-
id: _builtins.int
|
|
17032
|
-
"""
|
|
17033
|
-
The ID of entity this grant applies to.
|
|
17034
|
-
"""
|
|
17035
|
-
label: _builtins.str
|
|
17036
|
-
"""
|
|
17037
|
-
The current label of the entity this grant applies to, for display purposes.
|
|
17038
|
-
"""
|
|
17039
|
-
permissions: _builtins.str
|
|
17040
|
-
"""
|
|
17041
|
-
The level of access this User has to this entity. If null, this User has no access. (`read_only`, `read_write`)
|
|
17042
|
-
"""
|
|
17043
|
-
elif False:
|
|
17044
|
-
GetUserDatabaseGrantArgsDict: TypeAlias = Mapping[str, Any]
|
|
17045
|
-
|
|
17046
|
-
@pulumi.input_type
|
|
17047
|
-
class GetUserDatabaseGrantArgs:
|
|
17048
|
-
def __init__(__self__, *,
|
|
17049
|
-
id: _builtins.int,
|
|
17050
|
-
label: _builtins.str,
|
|
17051
|
-
permissions: _builtins.str):
|
|
17052
|
-
"""
|
|
17053
|
-
:param _builtins.int id: The ID of entity this grant applies to.
|
|
17054
|
-
:param _builtins.str label: The current label of the entity this grant applies to, for display purposes.
|
|
17055
|
-
:param _builtins.str permissions: The level of access this User has to this entity. If null, this User has no access. (`read_only`, `read_write`)
|
|
17056
|
-
"""
|
|
17057
|
-
pulumi.set(__self__, "id", id)
|
|
17058
|
-
pulumi.set(__self__, "label", label)
|
|
17059
|
-
pulumi.set(__self__, "permissions", permissions)
|
|
17060
|
-
|
|
17061
|
-
@_builtins.property
|
|
17062
|
-
@pulumi.getter
|
|
17063
|
-
def id(self) -> _builtins.int:
|
|
17064
|
-
"""
|
|
17065
|
-
The ID of entity this grant applies to.
|
|
17066
|
-
"""
|
|
17067
|
-
return pulumi.get(self, "id")
|
|
17068
|
-
|
|
17069
|
-
@id.setter
|
|
17070
|
-
def id(self, value: _builtins.int):
|
|
17071
|
-
pulumi.set(self, "id", value)
|
|
17072
|
-
|
|
17073
|
-
@_builtins.property
|
|
17074
|
-
@pulumi.getter
|
|
17075
|
-
def label(self) -> _builtins.str:
|
|
17998
|
+
def name(self) -> _builtins.str:
|
|
17076
17999
|
"""
|
|
17077
|
-
The
|
|
18000
|
+
The name of the field.
|
|
17078
18001
|
"""
|
|
17079
|
-
return pulumi.get(self, "
|
|
18002
|
+
return pulumi.get(self, "name")
|
|
17080
18003
|
|
|
17081
|
-
@
|
|
17082
|
-
def
|
|
17083
|
-
pulumi.set(self, "
|
|
18004
|
+
@name.setter
|
|
18005
|
+
def name(self, value: _builtins.str):
|
|
18006
|
+
pulumi.set(self, "name", value)
|
|
17084
18007
|
|
|
17085
18008
|
@_builtins.property
|
|
17086
|
-
@pulumi.getter
|
|
17087
|
-
def
|
|
18009
|
+
@pulumi.getter(name="oneOf")
|
|
18010
|
+
def one_of(self) -> _builtins.str:
|
|
17088
18011
|
"""
|
|
17089
|
-
|
|
18012
|
+
A list of acceptable single values for the field.
|
|
17090
18013
|
"""
|
|
17091
|
-
return pulumi.get(self, "
|
|
18014
|
+
return pulumi.get(self, "one_of")
|
|
17092
18015
|
|
|
17093
|
-
@
|
|
17094
|
-
def
|
|
17095
|
-
pulumi.set(self, "
|
|
18016
|
+
@one_of.setter
|
|
18017
|
+
def one_of(self, value: _builtins.str):
|
|
18018
|
+
pulumi.set(self, "one_of", value)
|
|
17096
18019
|
|
|
17097
18020
|
|
|
17098
18021
|
if not MYPY:
|
|
17099
|
-
class
|
|
18022
|
+
class GetUserDatabaseGrantArgsDict(TypedDict):
|
|
17100
18023
|
id: _builtins.int
|
|
17101
18024
|
"""
|
|
17102
18025
|
The ID of entity this grant applies to.
|
|
@@ -17110,10 +18033,10 @@ if not MYPY:
|
|
|
17110
18033
|
The level of access this User has to this entity. If null, this User has no access. (`read_only`, `read_write`)
|
|
17111
18034
|
"""
|
|
17112
18035
|
elif False:
|
|
17113
|
-
|
|
18036
|
+
GetUserDatabaseGrantArgsDict: TypeAlias = Mapping[str, Any]
|
|
17114
18037
|
|
|
17115
18038
|
@pulumi.input_type
|
|
17116
|
-
class
|
|
18039
|
+
class GetUserDatabaseGrantArgs:
|
|
17117
18040
|
def __init__(__self__, *,
|
|
17118
18041
|
id: _builtins.int,
|
|
17119
18042
|
label: _builtins.str,
|
|
@@ -17165,7 +18088,7 @@ class GetUserDomainGrantArgs:
|
|
|
17165
18088
|
|
|
17166
18089
|
|
|
17167
18090
|
if not MYPY:
|
|
17168
|
-
class
|
|
18091
|
+
class GetUserDomainGrantArgsDict(TypedDict):
|
|
17169
18092
|
id: _builtins.int
|
|
17170
18093
|
"""
|
|
17171
18094
|
The ID of entity this grant applies to.
|
|
@@ -17179,10 +18102,10 @@ if not MYPY:
|
|
|
17179
18102
|
The level of access this User has to this entity. If null, this User has no access. (`read_only`, `read_write`)
|
|
17180
18103
|
"""
|
|
17181
18104
|
elif False:
|
|
17182
|
-
|
|
18105
|
+
GetUserDomainGrantArgsDict: TypeAlias = Mapping[str, Any]
|
|
17183
18106
|
|
|
17184
18107
|
@pulumi.input_type
|
|
17185
|
-
class
|
|
18108
|
+
class GetUserDomainGrantArgs:
|
|
17186
18109
|
def __init__(__self__, *,
|
|
17187
18110
|
id: _builtins.int,
|
|
17188
18111
|
label: _builtins.str,
|
|
@@ -17234,7 +18157,7 @@ class GetUserFirewallGrantArgs:
|
|
|
17234
18157
|
|
|
17235
18158
|
|
|
17236
18159
|
if not MYPY:
|
|
17237
|
-
class
|
|
18160
|
+
class GetUserFirewallGrantArgsDict(TypedDict):
|
|
17238
18161
|
id: _builtins.int
|
|
17239
18162
|
"""
|
|
17240
18163
|
The ID of entity this grant applies to.
|
|
@@ -17248,10 +18171,10 @@ if not MYPY:
|
|
|
17248
18171
|
The level of access this User has to this entity. If null, this User has no access. (`read_only`, `read_write`)
|
|
17249
18172
|
"""
|
|
17250
18173
|
elif False:
|
|
17251
|
-
|
|
18174
|
+
GetUserFirewallGrantArgsDict: TypeAlias = Mapping[str, Any]
|
|
17252
18175
|
|
|
17253
18176
|
@pulumi.input_type
|
|
17254
|
-
class
|
|
18177
|
+
class GetUserFirewallGrantArgs:
|
|
17255
18178
|
def __init__(__self__, *,
|
|
17256
18179
|
id: _builtins.int,
|
|
17257
18180
|
label: _builtins.str,
|
|
@@ -17303,7 +18226,7 @@ class GetUserImageGrantArgs:
|
|
|
17303
18226
|
|
|
17304
18227
|
|
|
17305
18228
|
if not MYPY:
|
|
17306
|
-
class
|
|
18229
|
+
class GetUserImageGrantArgsDict(TypedDict):
|
|
17307
18230
|
id: _builtins.int
|
|
17308
18231
|
"""
|
|
17309
18232
|
The ID of entity this grant applies to.
|
|
@@ -17317,10 +18240,10 @@ if not MYPY:
|
|
|
17317
18240
|
The level of access this User has to this entity. If null, this User has no access. (`read_only`, `read_write`)
|
|
17318
18241
|
"""
|
|
17319
18242
|
elif False:
|
|
17320
|
-
|
|
18243
|
+
GetUserImageGrantArgsDict: TypeAlias = Mapping[str, Any]
|
|
17321
18244
|
|
|
17322
18245
|
@pulumi.input_type
|
|
17323
|
-
class
|
|
18246
|
+
class GetUserImageGrantArgs:
|
|
17324
18247
|
def __init__(__self__, *,
|
|
17325
18248
|
id: _builtins.int,
|
|
17326
18249
|
label: _builtins.str,
|
|
@@ -17372,7 +18295,7 @@ class GetUserLinodeGrantArgs:
|
|
|
17372
18295
|
|
|
17373
18296
|
|
|
17374
18297
|
if not MYPY:
|
|
17375
|
-
class
|
|
18298
|
+
class GetUserLinodeGrantArgsDict(TypedDict):
|
|
17376
18299
|
id: _builtins.int
|
|
17377
18300
|
"""
|
|
17378
18301
|
The ID of entity this grant applies to.
|
|
@@ -17386,10 +18309,10 @@ if not MYPY:
|
|
|
17386
18309
|
The level of access this User has to this entity. If null, this User has no access. (`read_only`, `read_write`)
|
|
17387
18310
|
"""
|
|
17388
18311
|
elif False:
|
|
17389
|
-
|
|
18312
|
+
GetUserLinodeGrantArgsDict: TypeAlias = Mapping[str, Any]
|
|
17390
18313
|
|
|
17391
18314
|
@pulumi.input_type
|
|
17392
|
-
class
|
|
18315
|
+
class GetUserLinodeGrantArgs:
|
|
17393
18316
|
def __init__(__self__, *,
|
|
17394
18317
|
id: _builtins.int,
|
|
17395
18318
|
label: _builtins.str,
|
|
@@ -17441,7 +18364,7 @@ class GetUserLongviewGrantArgs:
|
|
|
17441
18364
|
|
|
17442
18365
|
|
|
17443
18366
|
if not MYPY:
|
|
17444
|
-
class
|
|
18367
|
+
class GetUserLongviewGrantArgsDict(TypedDict):
|
|
17445
18368
|
id: _builtins.int
|
|
17446
18369
|
"""
|
|
17447
18370
|
The ID of entity this grant applies to.
|
|
@@ -17455,10 +18378,10 @@ if not MYPY:
|
|
|
17455
18378
|
The level of access this User has to this entity. If null, this User has no access. (`read_only`, `read_write`)
|
|
17456
18379
|
"""
|
|
17457
18380
|
elif False:
|
|
17458
|
-
|
|
18381
|
+
GetUserLongviewGrantArgsDict: TypeAlias = Mapping[str, Any]
|
|
17459
18382
|
|
|
17460
18383
|
@pulumi.input_type
|
|
17461
|
-
class
|
|
18384
|
+
class GetUserLongviewGrantArgs:
|
|
17462
18385
|
def __init__(__self__, *,
|
|
17463
18386
|
id: _builtins.int,
|
|
17464
18387
|
label: _builtins.str,
|
|
@@ -17510,7 +18433,7 @@ class GetUserNodebalancerGrantArgs:
|
|
|
17510
18433
|
|
|
17511
18434
|
|
|
17512
18435
|
if not MYPY:
|
|
17513
|
-
class
|
|
18436
|
+
class GetUserNodebalancerGrantArgsDict(TypedDict):
|
|
17514
18437
|
id: _builtins.int
|
|
17515
18438
|
"""
|
|
17516
18439
|
The ID of entity this grant applies to.
|
|
@@ -17524,10 +18447,10 @@ if not MYPY:
|
|
|
17524
18447
|
The level of access this User has to this entity. If null, this User has no access. (`read_only`, `read_write`)
|
|
17525
18448
|
"""
|
|
17526
18449
|
elif False:
|
|
17527
|
-
|
|
18450
|
+
GetUserNodebalancerGrantArgsDict: TypeAlias = Mapping[str, Any]
|
|
17528
18451
|
|
|
17529
18452
|
@pulumi.input_type
|
|
17530
|
-
class
|
|
18453
|
+
class GetUserNodebalancerGrantArgs:
|
|
17531
18454
|
def __init__(__self__, *,
|
|
17532
18455
|
id: _builtins.int,
|
|
17533
18456
|
label: _builtins.str,
|
|
@@ -17901,10 +18824,6 @@ if not MYPY:
|
|
|
17901
18824
|
"""
|
|
17902
18825
|
The date and time when this User’s current password was created. User passwords are first created during the Account sign-up process, and updated using the Reset Password webpage. null if this User has not created a password yet.
|
|
17903
18826
|
"""
|
|
17904
|
-
placement_group_grants: Sequence['GetUsersUserPlacementGroupGrantArgsDict']
|
|
17905
|
-
"""
|
|
17906
|
-
A set containing all of the user's active grants.
|
|
17907
|
-
"""
|
|
17908
18827
|
restricted: _builtins.bool
|
|
17909
18828
|
"""
|
|
17910
18829
|
If true, this User must be granted access to perform actions or access entities on this Account.
|
|
@@ -17958,7 +18877,6 @@ class GetUsersUserArgs:
|
|
|
17958
18877
|
longview_grants: Sequence['GetUsersUserLongviewGrantArgs'],
|
|
17959
18878
|
nodebalancer_grants: Sequence['GetUsersUserNodebalancerGrantArgs'],
|
|
17960
18879
|
password_created: _builtins.str,
|
|
17961
|
-
placement_group_grants: Sequence['GetUsersUserPlacementGroupGrantArgs'],
|
|
17962
18880
|
restricted: _builtins.bool,
|
|
17963
18881
|
ssh_keys: Sequence[_builtins.str],
|
|
17964
18882
|
stackscript_grants: Sequence['GetUsersUserStackscriptGrantArgs'],
|
|
@@ -17980,7 +18898,6 @@ class GetUsersUserArgs:
|
|
|
17980
18898
|
:param Sequence['GetUsersUserLongviewGrantArgs'] longview_grants: A set containing all of the user's active grants.
|
|
17981
18899
|
:param Sequence['GetUsersUserNodebalancerGrantArgs'] nodebalancer_grants: A set containing all of the user's active grants.
|
|
17982
18900
|
:param _builtins.str password_created: The date and time when this User’s current password was created. User passwords are first created during the Account sign-up process, and updated using the Reset Password webpage. null if this User has not created a password yet.
|
|
17983
|
-
:param Sequence['GetUsersUserPlacementGroupGrantArgs'] placement_group_grants: A set containing all of the user's active grants.
|
|
17984
18901
|
:param _builtins.bool restricted: If true, this User must be granted access to perform actions or access entities on this Account.
|
|
17985
18902
|
:param Sequence[_builtins.str] ssh_keys: A list of SSH Key labels added by this User. These are the keys that will be deployed if this User is included in the authorized_users field of a create Linode, rebuild Linode, or create Disk request.
|
|
17986
18903
|
:param Sequence['GetUsersUserStackscriptGrantArgs'] stackscript_grants: A set containing all of the user's active grants.
|
|
@@ -18002,7 +18919,6 @@ class GetUsersUserArgs:
|
|
|
18002
18919
|
pulumi.set(__self__, "longview_grants", longview_grants)
|
|
18003
18920
|
pulumi.set(__self__, "nodebalancer_grants", nodebalancer_grants)
|
|
18004
18921
|
pulumi.set(__self__, "password_created", password_created)
|
|
18005
|
-
pulumi.set(__self__, "placement_group_grants", placement_group_grants)
|
|
18006
18922
|
pulumi.set(__self__, "restricted", restricted)
|
|
18007
18923
|
pulumi.set(__self__, "ssh_keys", ssh_keys)
|
|
18008
18924
|
pulumi.set(__self__, "stackscript_grants", stackscript_grants)
|
|
@@ -18145,18 +19061,6 @@ class GetUsersUserArgs:
|
|
|
18145
19061
|
def password_created(self, value: _builtins.str):
|
|
18146
19062
|
pulumi.set(self, "password_created", value)
|
|
18147
19063
|
|
|
18148
|
-
@_builtins.property
|
|
18149
|
-
@pulumi.getter(name="placementGroupGrants")
|
|
18150
|
-
def placement_group_grants(self) -> Sequence['GetUsersUserPlacementGroupGrantArgs']:
|
|
18151
|
-
"""
|
|
18152
|
-
A set containing all of the user's active grants.
|
|
18153
|
-
"""
|
|
18154
|
-
return pulumi.get(self, "placement_group_grants")
|
|
18155
|
-
|
|
18156
|
-
@placement_group_grants.setter
|
|
18157
|
-
def placement_group_grants(self, value: Sequence['GetUsersUserPlacementGroupGrantArgs']):
|
|
18158
|
-
pulumi.set(self, "placement_group_grants", value)
|
|
18159
|
-
|
|
18160
19064
|
@_builtins.property
|
|
18161
19065
|
@pulumi.getter
|
|
18162
19066
|
def restricted(self) -> _builtins.bool:
|
|
@@ -18507,10 +19411,6 @@ if not MYPY:
|
|
|
18507
19411
|
"""
|
|
18508
19412
|
If true, this User may add NodeBalancers.
|
|
18509
19413
|
"""
|
|
18510
|
-
add_placement_groups: _builtins.bool
|
|
18511
|
-
"""
|
|
18512
|
-
If true, this User may add Placement Groups.
|
|
18513
|
-
"""
|
|
18514
19414
|
add_stackscripts: _builtins.bool
|
|
18515
19415
|
add_volumes: _builtins.bool
|
|
18516
19416
|
"""
|
|
@@ -18542,7 +19442,6 @@ class GetUsersUserGlobalGrantArgs:
|
|
|
18542
19442
|
add_linodes: _builtins.bool,
|
|
18543
19443
|
add_longview: _builtins.bool,
|
|
18544
19444
|
add_nodebalancers: _builtins.bool,
|
|
18545
|
-
add_placement_groups: _builtins.bool,
|
|
18546
19445
|
add_stackscripts: _builtins.bool,
|
|
18547
19446
|
add_volumes: _builtins.bool,
|
|
18548
19447
|
add_vpcs: _builtins.bool,
|
|
@@ -18557,7 +19456,6 @@ class GetUsersUserGlobalGrantArgs:
|
|
|
18557
19456
|
:param _builtins.bool add_linodes: If true, this User may create Linodes.
|
|
18558
19457
|
:param _builtins.bool add_longview: If true, this User may create Longview clients and view the current plan.
|
|
18559
19458
|
:param _builtins.bool add_nodebalancers: If true, this User may add NodeBalancers.
|
|
18560
|
-
:param _builtins.bool add_placement_groups: If true, this User may add Placement Groups.
|
|
18561
19459
|
:param _builtins.bool add_volumes: If true, this User may add Volumes.
|
|
18562
19460
|
:param _builtins.bool add_vpcs: If true, this User may add Virtual Private Clouds (VPCs).
|
|
18563
19461
|
:param _builtins.bool cancel_account: If true, this User may cancel the entire Account.
|
|
@@ -18571,7 +19469,6 @@ class GetUsersUserGlobalGrantArgs:
|
|
|
18571
19469
|
pulumi.set(__self__, "add_linodes", add_linodes)
|
|
18572
19470
|
pulumi.set(__self__, "add_longview", add_longview)
|
|
18573
19471
|
pulumi.set(__self__, "add_nodebalancers", add_nodebalancers)
|
|
18574
|
-
pulumi.set(__self__, "add_placement_groups", add_placement_groups)
|
|
18575
19472
|
pulumi.set(__self__, "add_stackscripts", add_stackscripts)
|
|
18576
19473
|
pulumi.set(__self__, "add_volumes", add_volumes)
|
|
18577
19474
|
pulumi.set(__self__, "add_vpcs", add_vpcs)
|
|
@@ -18674,18 +19571,6 @@ class GetUsersUserGlobalGrantArgs:
|
|
|
18674
19571
|
def add_nodebalancers(self, value: _builtins.bool):
|
|
18675
19572
|
pulumi.set(self, "add_nodebalancers", value)
|
|
18676
19573
|
|
|
18677
|
-
@_builtins.property
|
|
18678
|
-
@pulumi.getter(name="addPlacementGroups")
|
|
18679
|
-
def add_placement_groups(self) -> _builtins.bool:
|
|
18680
|
-
"""
|
|
18681
|
-
If true, this User may add Placement Groups.
|
|
18682
|
-
"""
|
|
18683
|
-
return pulumi.get(self, "add_placement_groups")
|
|
18684
|
-
|
|
18685
|
-
@add_placement_groups.setter
|
|
18686
|
-
def add_placement_groups(self, value: _builtins.bool):
|
|
18687
|
-
pulumi.set(self, "add_placement_groups", value)
|
|
18688
|
-
|
|
18689
19574
|
@_builtins.property
|
|
18690
19575
|
@pulumi.getter(name="addStackscripts")
|
|
18691
19576
|
def add_stackscripts(self) -> _builtins.bool:
|
|
@@ -19020,75 +19905,6 @@ class GetUsersUserNodebalancerGrantArgs:
|
|
|
19020
19905
|
pulumi.set(self, "permissions", value)
|
|
19021
19906
|
|
|
19022
19907
|
|
|
19023
|
-
if not MYPY:
|
|
19024
|
-
class GetUsersUserPlacementGroupGrantArgsDict(TypedDict):
|
|
19025
|
-
id: _builtins.int
|
|
19026
|
-
"""
|
|
19027
|
-
The ID of entity this grant applies to.
|
|
19028
|
-
"""
|
|
19029
|
-
label: _builtins.str
|
|
19030
|
-
"""
|
|
19031
|
-
The current label of the entity this grant applies to, for display purposes.
|
|
19032
|
-
"""
|
|
19033
|
-
permissions: _builtins.str
|
|
19034
|
-
"""
|
|
19035
|
-
The level of access this User has to this entity. If null, this User has no access.
|
|
19036
|
-
"""
|
|
19037
|
-
elif False:
|
|
19038
|
-
GetUsersUserPlacementGroupGrantArgsDict: TypeAlias = Mapping[str, Any]
|
|
19039
|
-
|
|
19040
|
-
@pulumi.input_type
|
|
19041
|
-
class GetUsersUserPlacementGroupGrantArgs:
|
|
19042
|
-
def __init__(__self__, *,
|
|
19043
|
-
id: _builtins.int,
|
|
19044
|
-
label: _builtins.str,
|
|
19045
|
-
permissions: _builtins.str):
|
|
19046
|
-
"""
|
|
19047
|
-
:param _builtins.int id: The ID of entity this grant applies to.
|
|
19048
|
-
:param _builtins.str label: The current label of the entity this grant applies to, for display purposes.
|
|
19049
|
-
:param _builtins.str permissions: The level of access this User has to this entity. If null, this User has no access.
|
|
19050
|
-
"""
|
|
19051
|
-
pulumi.set(__self__, "id", id)
|
|
19052
|
-
pulumi.set(__self__, "label", label)
|
|
19053
|
-
pulumi.set(__self__, "permissions", permissions)
|
|
19054
|
-
|
|
19055
|
-
@_builtins.property
|
|
19056
|
-
@pulumi.getter
|
|
19057
|
-
def id(self) -> _builtins.int:
|
|
19058
|
-
"""
|
|
19059
|
-
The ID of entity this grant applies to.
|
|
19060
|
-
"""
|
|
19061
|
-
return pulumi.get(self, "id")
|
|
19062
|
-
|
|
19063
|
-
@id.setter
|
|
19064
|
-
def id(self, value: _builtins.int):
|
|
19065
|
-
pulumi.set(self, "id", value)
|
|
19066
|
-
|
|
19067
|
-
@_builtins.property
|
|
19068
|
-
@pulumi.getter
|
|
19069
|
-
def label(self) -> _builtins.str:
|
|
19070
|
-
"""
|
|
19071
|
-
The current label of the entity this grant applies to, for display purposes.
|
|
19072
|
-
"""
|
|
19073
|
-
return pulumi.get(self, "label")
|
|
19074
|
-
|
|
19075
|
-
@label.setter
|
|
19076
|
-
def label(self, value: _builtins.str):
|
|
19077
|
-
pulumi.set(self, "label", value)
|
|
19078
|
-
|
|
19079
|
-
@_builtins.property
|
|
19080
|
-
@pulumi.getter
|
|
19081
|
-
def permissions(self) -> _builtins.str:
|
|
19082
|
-
"""
|
|
19083
|
-
The level of access this User has to this entity. If null, this User has no access.
|
|
19084
|
-
"""
|
|
19085
|
-
return pulumi.get(self, "permissions")
|
|
19086
|
-
|
|
19087
|
-
@permissions.setter
|
|
19088
|
-
def permissions(self, value: _builtins.str):
|
|
19089
|
-
pulumi.set(self, "permissions", value)
|
|
19090
|
-
|
|
19091
|
-
|
|
19092
19908
|
if not MYPY:
|
|
19093
19909
|
class GetUsersUserStackscriptGrantArgsDict(TypedDict):
|
|
19094
19910
|
id: _builtins.int
|
|
@@ -20123,6 +20939,18 @@ if not MYPY:
|
|
|
20123
20939
|
"""
|
|
20124
20940
|
The globally general API entity identifier for the Linode interface.
|
|
20125
20941
|
"""
|
|
20942
|
+
ipv6_addresses: Sequence['GetVpcIpsVpcIpIpv6AddressArgsDict']
|
|
20943
|
+
"""
|
|
20944
|
+
The addresses within the prefix that the interface is associated with.
|
|
20945
|
+
"""
|
|
20946
|
+
ipv6_is_public: _builtins.bool
|
|
20947
|
+
"""
|
|
20948
|
+
The is_public setting for the interface associated with this address.
|
|
20949
|
+
"""
|
|
20950
|
+
ipv6_range: _builtins.str
|
|
20951
|
+
"""
|
|
20952
|
+
The /64 prefix, in CIDR notation, assigned to an interface.
|
|
20953
|
+
"""
|
|
20126
20954
|
linode_id: _builtins.int
|
|
20127
20955
|
"""
|
|
20128
20956
|
The identifier for the Linode the VPC interface currently belongs to.
|
|
@@ -20165,6 +20993,9 @@ class GetVpcIpsVpcIpArgs:
|
|
|
20165
20993
|
config_id: _builtins.int,
|
|
20166
20994
|
gateway: _builtins.str,
|
|
20167
20995
|
interface_id: _builtins.int,
|
|
20996
|
+
ipv6_addresses: Sequence['GetVpcIpsVpcIpIpv6AddressArgs'],
|
|
20997
|
+
ipv6_is_public: _builtins.bool,
|
|
20998
|
+
ipv6_range: _builtins.str,
|
|
20168
20999
|
linode_id: _builtins.int,
|
|
20169
21000
|
nat11: _builtins.str,
|
|
20170
21001
|
prefix: _builtins.int,
|
|
@@ -20179,6 +21010,9 @@ class GetVpcIpsVpcIpArgs:
|
|
|
20179
21010
|
:param _builtins.int config_id: The globally general entity identifier for the Linode configuration profile where the VPC is included.
|
|
20180
21011
|
:param _builtins.str gateway: The default gateway for the VPC subnet that the IP or IP range belongs to.
|
|
20181
21012
|
:param _builtins.int interface_id: The globally general API entity identifier for the Linode interface.
|
|
21013
|
+
:param Sequence['GetVpcIpsVpcIpIpv6AddressArgs'] ipv6_addresses: The addresses within the prefix that the interface is associated with.
|
|
21014
|
+
:param _builtins.bool ipv6_is_public: The is_public setting for the interface associated with this address.
|
|
21015
|
+
:param _builtins.str ipv6_range: The /64 prefix, in CIDR notation, assigned to an interface.
|
|
20182
21016
|
:param _builtins.int linode_id: The identifier for the Linode the VPC interface currently belongs to.
|
|
20183
21017
|
:param _builtins.str nat11: The public IP address used for NAT 1:1 with the VPC. This is empty if NAT 1:1 isn't used.
|
|
20184
21018
|
:param _builtins.int prefix: The number of bits set in the subnet mask.
|
|
@@ -20195,6 +21029,9 @@ class GetVpcIpsVpcIpArgs:
|
|
|
20195
21029
|
pulumi.set(__self__, "config_id", config_id)
|
|
20196
21030
|
pulumi.set(__self__, "gateway", gateway)
|
|
20197
21031
|
pulumi.set(__self__, "interface_id", interface_id)
|
|
21032
|
+
pulumi.set(__self__, "ipv6_addresses", ipv6_addresses)
|
|
21033
|
+
pulumi.set(__self__, "ipv6_is_public", ipv6_is_public)
|
|
21034
|
+
pulumi.set(__self__, "ipv6_range", ipv6_range)
|
|
20198
21035
|
pulumi.set(__self__, "linode_id", linode_id)
|
|
20199
21036
|
pulumi.set(__self__, "nat11", nat11)
|
|
20200
21037
|
pulumi.set(__self__, "prefix", prefix)
|
|
@@ -20275,6 +21112,42 @@ class GetVpcIpsVpcIpArgs:
|
|
|
20275
21112
|
def interface_id(self, value: _builtins.int):
|
|
20276
21113
|
pulumi.set(self, "interface_id", value)
|
|
20277
21114
|
|
|
21115
|
+
@_builtins.property
|
|
21116
|
+
@pulumi.getter(name="ipv6Addresses")
|
|
21117
|
+
def ipv6_addresses(self) -> Sequence['GetVpcIpsVpcIpIpv6AddressArgs']:
|
|
21118
|
+
"""
|
|
21119
|
+
The addresses within the prefix that the interface is associated with.
|
|
21120
|
+
"""
|
|
21121
|
+
return pulumi.get(self, "ipv6_addresses")
|
|
21122
|
+
|
|
21123
|
+
@ipv6_addresses.setter
|
|
21124
|
+
def ipv6_addresses(self, value: Sequence['GetVpcIpsVpcIpIpv6AddressArgs']):
|
|
21125
|
+
pulumi.set(self, "ipv6_addresses", value)
|
|
21126
|
+
|
|
21127
|
+
@_builtins.property
|
|
21128
|
+
@pulumi.getter(name="ipv6IsPublic")
|
|
21129
|
+
def ipv6_is_public(self) -> _builtins.bool:
|
|
21130
|
+
"""
|
|
21131
|
+
The is_public setting for the interface associated with this address.
|
|
21132
|
+
"""
|
|
21133
|
+
return pulumi.get(self, "ipv6_is_public")
|
|
21134
|
+
|
|
21135
|
+
@ipv6_is_public.setter
|
|
21136
|
+
def ipv6_is_public(self, value: _builtins.bool):
|
|
21137
|
+
pulumi.set(self, "ipv6_is_public", value)
|
|
21138
|
+
|
|
21139
|
+
@_builtins.property
|
|
21140
|
+
@pulumi.getter(name="ipv6Range")
|
|
21141
|
+
def ipv6_range(self) -> _builtins.str:
|
|
21142
|
+
"""
|
|
21143
|
+
The /64 prefix, in CIDR notation, assigned to an interface.
|
|
21144
|
+
"""
|
|
21145
|
+
return pulumi.get(self, "ipv6_range")
|
|
21146
|
+
|
|
21147
|
+
@ipv6_range.setter
|
|
21148
|
+
def ipv6_range(self, value: _builtins.str):
|
|
21149
|
+
pulumi.set(self, "ipv6_range", value)
|
|
21150
|
+
|
|
20278
21151
|
@_builtins.property
|
|
20279
21152
|
@pulumi.getter(name="linodeId")
|
|
20280
21153
|
def linode_id(self) -> _builtins.int:
|
|
@@ -20362,6 +21235,37 @@ class GetVpcIpsVpcIpArgs:
|
|
|
20362
21235
|
pulumi.set(self, "vpc_id", value)
|
|
20363
21236
|
|
|
20364
21237
|
|
|
21238
|
+
if not MYPY:
|
|
21239
|
+
class GetVpcIpsVpcIpIpv6AddressArgsDict(TypedDict):
|
|
21240
|
+
slaac_address: _builtins.str
|
|
21241
|
+
"""
|
|
21242
|
+
A specific address within the prefix that the interface is expected to autoconfigure through SLAAC.
|
|
21243
|
+
"""
|
|
21244
|
+
elif False:
|
|
21245
|
+
GetVpcIpsVpcIpIpv6AddressArgsDict: TypeAlias = Mapping[str, Any]
|
|
21246
|
+
|
|
21247
|
+
@pulumi.input_type
|
|
21248
|
+
class GetVpcIpsVpcIpIpv6AddressArgs:
|
|
21249
|
+
def __init__(__self__, *,
|
|
21250
|
+
slaac_address: _builtins.str):
|
|
21251
|
+
"""
|
|
21252
|
+
:param _builtins.str slaac_address: A specific address within the prefix that the interface is expected to autoconfigure through SLAAC.
|
|
21253
|
+
"""
|
|
21254
|
+
pulumi.set(__self__, "slaac_address", slaac_address)
|
|
21255
|
+
|
|
21256
|
+
@_builtins.property
|
|
21257
|
+
@pulumi.getter(name="slaacAddress")
|
|
21258
|
+
def slaac_address(self) -> _builtins.str:
|
|
21259
|
+
"""
|
|
21260
|
+
A specific address within the prefix that the interface is expected to autoconfigure through SLAAC.
|
|
21261
|
+
"""
|
|
21262
|
+
return pulumi.get(self, "slaac_address")
|
|
21263
|
+
|
|
21264
|
+
@slaac_address.setter
|
|
21265
|
+
def slaac_address(self, value: _builtins.str):
|
|
21266
|
+
pulumi.set(self, "slaac_address", value)
|
|
21267
|
+
|
|
21268
|
+
|
|
20365
21269
|
if not MYPY:
|
|
20366
21270
|
class GetVpcSubnetsFilterArgsDict(TypedDict):
|
|
20367
21271
|
name: _builtins.str
|
|
@@ -20446,6 +21350,10 @@ if not MYPY:
|
|
|
20446
21350
|
"""
|
|
20447
21351
|
The IPv4 range of this subnet in CIDR format.
|
|
20448
21352
|
"""
|
|
21353
|
+
ipv6s: Sequence['GetVpcSubnetsVpcSubnetIpv6ArgsDict']
|
|
21354
|
+
"""
|
|
21355
|
+
The IPv6 ranges of this subnet.
|
|
21356
|
+
"""
|
|
20449
21357
|
label: _builtins.str
|
|
20450
21358
|
"""
|
|
20451
21359
|
The label of the VPC subnet.
|
|
@@ -20467,6 +21375,7 @@ class GetVpcSubnetsVpcSubnetArgs:
|
|
|
20467
21375
|
created: _builtins.str,
|
|
20468
21376
|
id: _builtins.int,
|
|
20469
21377
|
ipv4: _builtins.str,
|
|
21378
|
+
ipv6s: Sequence['GetVpcSubnetsVpcSubnetIpv6Args'],
|
|
20470
21379
|
label: _builtins.str,
|
|
20471
21380
|
linodes: Sequence['GetVpcSubnetsVpcSubnetLinodeArgs'],
|
|
20472
21381
|
updated: _builtins.str):
|
|
@@ -20474,6 +21383,7 @@ class GetVpcSubnetsVpcSubnetArgs:
|
|
|
20474
21383
|
:param _builtins.str created: The date and time when the VPC Subnet was created.
|
|
20475
21384
|
:param _builtins.int id: The unique id of the VPC subnet.
|
|
20476
21385
|
:param _builtins.str ipv4: The IPv4 range of this subnet in CIDR format.
|
|
21386
|
+
:param Sequence['GetVpcSubnetsVpcSubnetIpv6Args'] ipv6s: The IPv6 ranges of this subnet.
|
|
20477
21387
|
:param _builtins.str label: The label of the VPC subnet.
|
|
20478
21388
|
:param Sequence['GetVpcSubnetsVpcSubnetLinodeArgs'] linodes: A list of Linode IDs that added to this subnet.
|
|
20479
21389
|
:param _builtins.str updated: The date and time when the VPC Subnet was last updated.
|
|
@@ -20481,6 +21391,7 @@ class GetVpcSubnetsVpcSubnetArgs:
|
|
|
20481
21391
|
pulumi.set(__self__, "created", created)
|
|
20482
21392
|
pulumi.set(__self__, "id", id)
|
|
20483
21393
|
pulumi.set(__self__, "ipv4", ipv4)
|
|
21394
|
+
pulumi.set(__self__, "ipv6s", ipv6s)
|
|
20484
21395
|
pulumi.set(__self__, "label", label)
|
|
20485
21396
|
pulumi.set(__self__, "linodes", linodes)
|
|
20486
21397
|
pulumi.set(__self__, "updated", updated)
|
|
@@ -20521,6 +21432,18 @@ class GetVpcSubnetsVpcSubnetArgs:
|
|
|
20521
21432
|
def ipv4(self, value: _builtins.str):
|
|
20522
21433
|
pulumi.set(self, "ipv4", value)
|
|
20523
21434
|
|
|
21435
|
+
@_builtins.property
|
|
21436
|
+
@pulumi.getter
|
|
21437
|
+
def ipv6s(self) -> Sequence['GetVpcSubnetsVpcSubnetIpv6Args']:
|
|
21438
|
+
"""
|
|
21439
|
+
The IPv6 ranges of this subnet.
|
|
21440
|
+
"""
|
|
21441
|
+
return pulumi.get(self, "ipv6s")
|
|
21442
|
+
|
|
21443
|
+
@ipv6s.setter
|
|
21444
|
+
def ipv6s(self, value: Sequence['GetVpcSubnetsVpcSubnetIpv6Args']):
|
|
21445
|
+
pulumi.set(self, "ipv6s", value)
|
|
21446
|
+
|
|
20524
21447
|
@_builtins.property
|
|
20525
21448
|
@pulumi.getter
|
|
20526
21449
|
def label(self) -> _builtins.str:
|
|
@@ -20558,6 +21481,37 @@ class GetVpcSubnetsVpcSubnetArgs:
|
|
|
20558
21481
|
pulumi.set(self, "updated", value)
|
|
20559
21482
|
|
|
20560
21483
|
|
|
21484
|
+
if not MYPY:
|
|
21485
|
+
class GetVpcSubnetsVpcSubnetIpv6ArgsDict(TypedDict):
|
|
21486
|
+
range: _builtins.str
|
|
21487
|
+
"""
|
|
21488
|
+
An IPv6 range allocated to this subnet.
|
|
21489
|
+
"""
|
|
21490
|
+
elif False:
|
|
21491
|
+
GetVpcSubnetsVpcSubnetIpv6ArgsDict: TypeAlias = Mapping[str, Any]
|
|
21492
|
+
|
|
21493
|
+
@pulumi.input_type
|
|
21494
|
+
class GetVpcSubnetsVpcSubnetIpv6Args:
|
|
21495
|
+
def __init__(__self__, *,
|
|
21496
|
+
range: _builtins.str):
|
|
21497
|
+
"""
|
|
21498
|
+
:param _builtins.str range: An IPv6 range allocated to this subnet.
|
|
21499
|
+
"""
|
|
21500
|
+
pulumi.set(__self__, "range", range)
|
|
21501
|
+
|
|
21502
|
+
@_builtins.property
|
|
21503
|
+
@pulumi.getter
|
|
21504
|
+
def range(self) -> _builtins.str:
|
|
21505
|
+
"""
|
|
21506
|
+
An IPv6 range allocated to this subnet.
|
|
21507
|
+
"""
|
|
21508
|
+
return pulumi.get(self, "range")
|
|
21509
|
+
|
|
21510
|
+
@range.setter
|
|
21511
|
+
def range(self, value: _builtins.str):
|
|
21512
|
+
pulumi.set(self, "range", value)
|
|
21513
|
+
|
|
21514
|
+
|
|
20561
21515
|
if not MYPY:
|
|
20562
21516
|
class GetVpcSubnetsVpcSubnetLinodeArgsDict(TypedDict):
|
|
20563
21517
|
id: _builtins.int
|
|
@@ -20728,6 +21682,10 @@ if not MYPY:
|
|
|
20728
21682
|
"""
|
|
20729
21683
|
The unique id of this VPC.
|
|
20730
21684
|
"""
|
|
21685
|
+
ipv6s: Sequence['GetVpcsVpcIpv6ArgsDict']
|
|
21686
|
+
"""
|
|
21687
|
+
A list of IPv6 allocations under this VPC.
|
|
21688
|
+
"""
|
|
20731
21689
|
label: _builtins.str
|
|
20732
21690
|
"""
|
|
20733
21691
|
The label of the VPC.
|
|
@@ -20749,6 +21707,7 @@ class GetVpcsVpcArgs:
|
|
|
20749
21707
|
created: _builtins.str,
|
|
20750
21708
|
description: _builtins.str,
|
|
20751
21709
|
id: _builtins.str,
|
|
21710
|
+
ipv6s: Sequence['GetVpcsVpcIpv6Args'],
|
|
20752
21711
|
label: _builtins.str,
|
|
20753
21712
|
region: _builtins.str,
|
|
20754
21713
|
updated: _builtins.str):
|
|
@@ -20756,6 +21715,7 @@ class GetVpcsVpcArgs:
|
|
|
20756
21715
|
:param _builtins.str created: The date and time when the VPC was created.
|
|
20757
21716
|
:param _builtins.str description: The user-defined description of this VPC.
|
|
20758
21717
|
:param _builtins.str id: The unique id of this VPC.
|
|
21718
|
+
:param Sequence['GetVpcsVpcIpv6Args'] ipv6s: A list of IPv6 allocations under this VPC.
|
|
20759
21719
|
:param _builtins.str label: The label of the VPC.
|
|
20760
21720
|
:param _builtins.str region: The region where the VPC is deployed.
|
|
20761
21721
|
:param _builtins.str updated: The date and time when the VPC was last updated.
|
|
@@ -20763,6 +21723,7 @@ class GetVpcsVpcArgs:
|
|
|
20763
21723
|
pulumi.set(__self__, "created", created)
|
|
20764
21724
|
pulumi.set(__self__, "description", description)
|
|
20765
21725
|
pulumi.set(__self__, "id", id)
|
|
21726
|
+
pulumi.set(__self__, "ipv6s", ipv6s)
|
|
20766
21727
|
pulumi.set(__self__, "label", label)
|
|
20767
21728
|
pulumi.set(__self__, "region", region)
|
|
20768
21729
|
pulumi.set(__self__, "updated", updated)
|
|
@@ -20803,6 +21764,18 @@ class GetVpcsVpcArgs:
|
|
|
20803
21764
|
def id(self, value: _builtins.str):
|
|
20804
21765
|
pulumi.set(self, "id", value)
|
|
20805
21766
|
|
|
21767
|
+
@_builtins.property
|
|
21768
|
+
@pulumi.getter
|
|
21769
|
+
def ipv6s(self) -> Sequence['GetVpcsVpcIpv6Args']:
|
|
21770
|
+
"""
|
|
21771
|
+
A list of IPv6 allocations under this VPC.
|
|
21772
|
+
"""
|
|
21773
|
+
return pulumi.get(self, "ipv6s")
|
|
21774
|
+
|
|
21775
|
+
@ipv6s.setter
|
|
21776
|
+
def ipv6s(self, value: Sequence['GetVpcsVpcIpv6Args']):
|
|
21777
|
+
pulumi.set(self, "ipv6s", value)
|
|
21778
|
+
|
|
20806
21779
|
@_builtins.property
|
|
20807
21780
|
@pulumi.getter
|
|
20808
21781
|
def label(self) -> _builtins.str:
|
|
@@ -20840,3 +21813,34 @@ class GetVpcsVpcArgs:
|
|
|
20840
21813
|
pulumi.set(self, "updated", value)
|
|
20841
21814
|
|
|
20842
21815
|
|
|
21816
|
+
if not MYPY:
|
|
21817
|
+
class GetVpcsVpcIpv6ArgsDict(TypedDict):
|
|
21818
|
+
range: _builtins.str
|
|
21819
|
+
"""
|
|
21820
|
+
The IPv6 range assigned to this VPC.
|
|
21821
|
+
"""
|
|
21822
|
+
elif False:
|
|
21823
|
+
GetVpcsVpcIpv6ArgsDict: TypeAlias = Mapping[str, Any]
|
|
21824
|
+
|
|
21825
|
+
@pulumi.input_type
|
|
21826
|
+
class GetVpcsVpcIpv6Args:
|
|
21827
|
+
def __init__(__self__, *,
|
|
21828
|
+
range: _builtins.str):
|
|
21829
|
+
"""
|
|
21830
|
+
:param _builtins.str range: The IPv6 range assigned to this VPC.
|
|
21831
|
+
"""
|
|
21832
|
+
pulumi.set(__self__, "range", range)
|
|
21833
|
+
|
|
21834
|
+
@_builtins.property
|
|
21835
|
+
@pulumi.getter
|
|
21836
|
+
def range(self) -> _builtins.str:
|
|
21837
|
+
"""
|
|
21838
|
+
The IPv6 range assigned to this VPC.
|
|
21839
|
+
"""
|
|
21840
|
+
return pulumi.get(self, "range")
|
|
21841
|
+
|
|
21842
|
+
@range.setter
|
|
21843
|
+
def range(self, value: _builtins.str):
|
|
21844
|
+
pulumi.set(self, "range", value)
|
|
21845
|
+
|
|
21846
|
+
|