pulumi-linode 5.3.0a1757561362__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 +1182 -293
- 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_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/node_balancer.py +54 -3
- pulumi_linode/node_balancer_node.py +75 -0
- pulumi_linode/outputs.py +1254 -201
- 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.0a1757561362.dist-info → pulumi_linode-5.4.0.dist-info}/METADATA +1 -1
- {pulumi_linode-5.3.0a1757561362.dist-info → pulumi_linode-5.4.0.dist-info}/RECORD +28 -26
- {pulumi_linode-5.3.0a1757561362.dist-info → pulumi_linode-5.4.0.dist-info}/WHEEL +0 -0
- {pulumi_linode-5.3.0a1757561362.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]
|
|
@@ -5566,6 +6200,57 @@ class NodeBalancerTransferArgs:
|
|
|
5566
6200
|
pulumi.set(self, "total", value)
|
|
5567
6201
|
|
|
5568
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
|
+
|
|
5569
6254
|
if not MYPY:
|
|
5570
6255
|
class ObjectStorageBucketCertArgsDict(TypedDict):
|
|
5571
6256
|
certificate: pulumi.Input[_builtins.str]
|
|
@@ -6433,10 +7118,6 @@ if not MYPY:
|
|
|
6433
7118
|
"""
|
|
6434
7119
|
If true, this User may add NodeBalancers.
|
|
6435
7120
|
"""
|
|
6436
|
-
add_placement_groups: NotRequired[pulumi.Input[_builtins.bool]]
|
|
6437
|
-
"""
|
|
6438
|
-
If true, this User may add Placement Groups.
|
|
6439
|
-
"""
|
|
6440
7121
|
add_stackscripts: NotRequired[pulumi.Input[_builtins.bool]]
|
|
6441
7122
|
"""
|
|
6442
7123
|
If true, this User may add StackScripts.
|
|
@@ -6471,7 +7152,6 @@ class UserGlobalGrantsArgs:
|
|
|
6471
7152
|
add_linodes: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
6472
7153
|
add_longview: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
6473
7154
|
add_nodebalancers: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
6474
|
-
add_placement_groups: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
6475
7155
|
add_stackscripts: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
6476
7156
|
add_volumes: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
6477
7157
|
add_vpcs: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
@@ -6486,7 +7166,6 @@ class UserGlobalGrantsArgs:
|
|
|
6486
7166
|
:param pulumi.Input[_builtins.bool] add_linodes: If true, this User may create Linodes.
|
|
6487
7167
|
:param pulumi.Input[_builtins.bool] add_longview: If true, this User may create Longview clients and view the current plan.
|
|
6488
7168
|
:param pulumi.Input[_builtins.bool] add_nodebalancers: If true, this User may add NodeBalancers.
|
|
6489
|
-
:param pulumi.Input[_builtins.bool] add_placement_groups: If true, this User may add Placement Groups.
|
|
6490
7169
|
:param pulumi.Input[_builtins.bool] add_stackscripts: If true, this User may add StackScripts.
|
|
6491
7170
|
:param pulumi.Input[_builtins.bool] add_volumes: If true, this User may add Volumes.
|
|
6492
7171
|
:param pulumi.Input[_builtins.bool] add_vpcs: If true, this User may add Virtual Private Clouds (VPCs).
|
|
@@ -6509,8 +7188,6 @@ class UserGlobalGrantsArgs:
|
|
|
6509
7188
|
pulumi.set(__self__, "add_longview", add_longview)
|
|
6510
7189
|
if add_nodebalancers is not None:
|
|
6511
7190
|
pulumi.set(__self__, "add_nodebalancers", add_nodebalancers)
|
|
6512
|
-
if add_placement_groups is not None:
|
|
6513
|
-
pulumi.set(__self__, "add_placement_groups", add_placement_groups)
|
|
6514
7191
|
if add_stackscripts is not None:
|
|
6515
7192
|
pulumi.set(__self__, "add_stackscripts", add_stackscripts)
|
|
6516
7193
|
if add_volumes is not None:
|
|
@@ -6618,18 +7295,6 @@ class UserGlobalGrantsArgs:
|
|
|
6618
7295
|
def add_nodebalancers(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
6619
7296
|
pulumi.set(self, "add_nodebalancers", value)
|
|
6620
7297
|
|
|
6621
|
-
@_builtins.property
|
|
6622
|
-
@pulumi.getter(name="addPlacementGroups")
|
|
6623
|
-
def add_placement_groups(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
6624
|
-
"""
|
|
6625
|
-
If true, this User may add Placement Groups.
|
|
6626
|
-
"""
|
|
6627
|
-
return pulumi.get(self, "add_placement_groups")
|
|
6628
|
-
|
|
6629
|
-
@add_placement_groups.setter
|
|
6630
|
-
def add_placement_groups(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
6631
|
-
pulumi.set(self, "add_placement_groups", value)
|
|
6632
|
-
|
|
6633
7298
|
@_builtins.property
|
|
6634
7299
|
@pulumi.getter(name="addStackscripts")
|
|
6635
7300
|
def add_stackscripts(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
@@ -6755,57 +7420,7 @@ elif False:
|
|
|
6755
7420
|
UserLinodeGrantArgsDict: TypeAlias = Mapping[str, Any]
|
|
6756
7421
|
|
|
6757
7422
|
@pulumi.input_type
|
|
6758
|
-
class UserLinodeGrantArgs:
|
|
6759
|
-
def __init__(__self__, *,
|
|
6760
|
-
id: pulumi.Input[_builtins.int],
|
|
6761
|
-
permissions: pulumi.Input[_builtins.str]):
|
|
6762
|
-
"""
|
|
6763
|
-
:param pulumi.Input[_builtins.int] id: The ID of the entity this grant applies to.
|
|
6764
|
-
:param pulumi.Input[_builtins.str] permissions: The level of access this User has to this entity. If null, this User has no access.
|
|
6765
|
-
"""
|
|
6766
|
-
pulumi.set(__self__, "id", id)
|
|
6767
|
-
pulumi.set(__self__, "permissions", permissions)
|
|
6768
|
-
|
|
6769
|
-
@_builtins.property
|
|
6770
|
-
@pulumi.getter
|
|
6771
|
-
def id(self) -> pulumi.Input[_builtins.int]:
|
|
6772
|
-
"""
|
|
6773
|
-
The ID of the entity this grant applies to.
|
|
6774
|
-
"""
|
|
6775
|
-
return pulumi.get(self, "id")
|
|
6776
|
-
|
|
6777
|
-
@id.setter
|
|
6778
|
-
def id(self, value: pulumi.Input[_builtins.int]):
|
|
6779
|
-
pulumi.set(self, "id", value)
|
|
6780
|
-
|
|
6781
|
-
@_builtins.property
|
|
6782
|
-
@pulumi.getter
|
|
6783
|
-
def permissions(self) -> pulumi.Input[_builtins.str]:
|
|
6784
|
-
"""
|
|
6785
|
-
The level of access this User has to this entity. If null, this User has no access.
|
|
6786
|
-
"""
|
|
6787
|
-
return pulumi.get(self, "permissions")
|
|
6788
|
-
|
|
6789
|
-
@permissions.setter
|
|
6790
|
-
def permissions(self, value: pulumi.Input[_builtins.str]):
|
|
6791
|
-
pulumi.set(self, "permissions", value)
|
|
6792
|
-
|
|
6793
|
-
|
|
6794
|
-
if not MYPY:
|
|
6795
|
-
class UserLongviewGrantArgsDict(TypedDict):
|
|
6796
|
-
id: pulumi.Input[_builtins.int]
|
|
6797
|
-
"""
|
|
6798
|
-
The ID of the entity this grant applies to.
|
|
6799
|
-
"""
|
|
6800
|
-
permissions: pulumi.Input[_builtins.str]
|
|
6801
|
-
"""
|
|
6802
|
-
The level of access this User has to this entity. If null, this User has no access.
|
|
6803
|
-
"""
|
|
6804
|
-
elif False:
|
|
6805
|
-
UserLongviewGrantArgsDict: TypeAlias = Mapping[str, Any]
|
|
6806
|
-
|
|
6807
|
-
@pulumi.input_type
|
|
6808
|
-
class UserLongviewGrantArgs:
|
|
7423
|
+
class UserLinodeGrantArgs:
|
|
6809
7424
|
def __init__(__self__, *,
|
|
6810
7425
|
id: pulumi.Input[_builtins.int],
|
|
6811
7426
|
permissions: pulumi.Input[_builtins.str]):
|
|
@@ -6842,7 +7457,7 @@ class UserLongviewGrantArgs:
|
|
|
6842
7457
|
|
|
6843
7458
|
|
|
6844
7459
|
if not MYPY:
|
|
6845
|
-
class
|
|
7460
|
+
class UserLongviewGrantArgsDict(TypedDict):
|
|
6846
7461
|
id: pulumi.Input[_builtins.int]
|
|
6847
7462
|
"""
|
|
6848
7463
|
The ID of the entity this grant applies to.
|
|
@@ -6852,10 +7467,10 @@ if not MYPY:
|
|
|
6852
7467
|
The level of access this User has to this entity. If null, this User has no access.
|
|
6853
7468
|
"""
|
|
6854
7469
|
elif False:
|
|
6855
|
-
|
|
7470
|
+
UserLongviewGrantArgsDict: TypeAlias = Mapping[str, Any]
|
|
6856
7471
|
|
|
6857
7472
|
@pulumi.input_type
|
|
6858
|
-
class
|
|
7473
|
+
class UserLongviewGrantArgs:
|
|
6859
7474
|
def __init__(__self__, *,
|
|
6860
7475
|
id: pulumi.Input[_builtins.int],
|
|
6861
7476
|
permissions: pulumi.Input[_builtins.str]):
|
|
@@ -6892,7 +7507,7 @@ class UserNodebalancerGrantArgs:
|
|
|
6892
7507
|
|
|
6893
7508
|
|
|
6894
7509
|
if not MYPY:
|
|
6895
|
-
class
|
|
7510
|
+
class UserNodebalancerGrantArgsDict(TypedDict):
|
|
6896
7511
|
id: pulumi.Input[_builtins.int]
|
|
6897
7512
|
"""
|
|
6898
7513
|
The ID of the entity this grant applies to.
|
|
@@ -6902,10 +7517,10 @@ if not MYPY:
|
|
|
6902
7517
|
The level of access this User has to this entity. If null, this User has no access.
|
|
6903
7518
|
"""
|
|
6904
7519
|
elif False:
|
|
6905
|
-
|
|
7520
|
+
UserNodebalancerGrantArgsDict: TypeAlias = Mapping[str, Any]
|
|
6906
7521
|
|
|
6907
7522
|
@pulumi.input_type
|
|
6908
|
-
class
|
|
7523
|
+
class UserNodebalancerGrantArgs:
|
|
6909
7524
|
def __init__(__self__, *,
|
|
6910
7525
|
id: pulumi.Input[_builtins.int],
|
|
6911
7526
|
permissions: pulumi.Input[_builtins.str]):
|
|
@@ -7163,6 +7778,110 @@ class VolumeTimeoutsArgs:
|
|
|
7163
7778
|
pulumi.set(self, "update", value)
|
|
7164
7779
|
|
|
7165
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")
|
|
7867
|
+
|
|
7868
|
+
@allocated_range.setter
|
|
7869
|
+
def allocated_range(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
7870
|
+
pulumi.set(self, "allocated_range", value)
|
|
7871
|
+
|
|
7872
|
+
@_builtins.property
|
|
7873
|
+
@pulumi.getter
|
|
7874
|
+
def range(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
7875
|
+
"""
|
|
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.
|
|
7877
|
+
"""
|
|
7878
|
+
return pulumi.get(self, "range")
|
|
7879
|
+
|
|
7880
|
+
@range.setter
|
|
7881
|
+
def range(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
7882
|
+
pulumi.set(self, "range", value)
|
|
7883
|
+
|
|
7884
|
+
|
|
7166
7885
|
if not MYPY:
|
|
7167
7886
|
class VpcSubnetLinodeArgsDict(TypedDict):
|
|
7168
7887
|
id: pulumi.Input[_builtins.int]
|
|
@@ -8379,6 +9098,10 @@ if not MYPY:
|
|
|
8379
9098
|
"""
|
|
8380
9099
|
A unique, user-defined string referring to the Managed Database.
|
|
8381
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
|
+
"""
|
|
8382
9105
|
region: _builtins.str
|
|
8383
9106
|
"""
|
|
8384
9107
|
The region to use for the Managed Database.
|
|
@@ -8423,6 +9146,7 @@ class GetDatabasesDatabaseArgs:
|
|
|
8423
9146
|
id: _builtins.int,
|
|
8424
9147
|
instance_uri: _builtins.str,
|
|
8425
9148
|
label: _builtins.str,
|
|
9149
|
+
private_network: 'GetDatabasesDatabasePrivateNetworkArgs',
|
|
8426
9150
|
region: _builtins.str,
|
|
8427
9151
|
replication_type: _builtins.str,
|
|
8428
9152
|
ssl_connection: _builtins.bool,
|
|
@@ -8441,6 +9165,7 @@ class GetDatabasesDatabaseArgs:
|
|
|
8441
9165
|
:param _builtins.int id: The ID of the Managed Database.
|
|
8442
9166
|
:param _builtins.str instance_uri: he API route for the database instance.
|
|
8443
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.
|
|
8444
9169
|
:param _builtins.str region: The region to use for the Managed Database.
|
|
8445
9170
|
:param _builtins.str replication_type: The replication method used for the Managed Database.
|
|
8446
9171
|
:param _builtins.bool ssl_connection: Whether to require SSL credentials to establish a connection to the Managed Database.
|
|
@@ -8459,6 +9184,7 @@ class GetDatabasesDatabaseArgs:
|
|
|
8459
9184
|
pulumi.set(__self__, "id", id)
|
|
8460
9185
|
pulumi.set(__self__, "instance_uri", instance_uri)
|
|
8461
9186
|
pulumi.set(__self__, "label", label)
|
|
9187
|
+
pulumi.set(__self__, "private_network", private_network)
|
|
8462
9188
|
pulumi.set(__self__, "region", region)
|
|
8463
9189
|
pulumi.set(__self__, "replication_type", replication_type)
|
|
8464
9190
|
pulumi.set(__self__, "ssl_connection", ssl_connection)
|
|
@@ -8587,6 +9313,18 @@ class GetDatabasesDatabaseArgs:
|
|
|
8587
9313
|
def label(self, value: _builtins.str):
|
|
8588
9314
|
pulumi.set(self, "label", value)
|
|
8589
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
|
+
|
|
8590
9328
|
@_builtins.property
|
|
8591
9329
|
@pulumi.getter
|
|
8592
9330
|
def region(self) -> _builtins.str:
|
|
@@ -8672,6 +9410,75 @@ class GetDatabasesDatabaseArgs:
|
|
|
8672
9410
|
pulumi.set(self, "version", value)
|
|
8673
9411
|
|
|
8674
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
|
+
|
|
8675
9482
|
if not MYPY:
|
|
8676
9483
|
class GetDatabasesFilterArgsDict(TypedDict):
|
|
8677
9484
|
name: _builtins.str
|
|
@@ -14837,6 +15644,76 @@ class GetNodebalancerConfigsNodebalancerConfigNodeStatusArgs:
|
|
|
14837
15644
|
pulumi.set(self, "up", value)
|
|
14838
15645
|
|
|
14839
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
|
+
|
|
14840
15717
|
if not MYPY:
|
|
14841
15718
|
class GetNodebalancersFilterArgsDict(TypedDict):
|
|
14842
15719
|
name: _builtins.str
|
|
@@ -17118,100 +17995,31 @@ class GetStackScriptsStackscriptUserDefinedFieldArgs:
|
|
|
17118
17995
|
|
|
17119
17996
|
@_builtins.property
|
|
17120
17997
|
@pulumi.getter
|
|
17121
|
-
def name(self) -> _builtins.str:
|
|
17122
|
-
"""
|
|
17123
|
-
The name of the field.
|
|
17124
|
-
"""
|
|
17125
|
-
return pulumi.get(self, "name")
|
|
17126
|
-
|
|
17127
|
-
@name.setter
|
|
17128
|
-
def name(self, value: _builtins.str):
|
|
17129
|
-
pulumi.set(self, "name", value)
|
|
17130
|
-
|
|
17131
|
-
@_builtins.property
|
|
17132
|
-
@pulumi.getter(name="oneOf")
|
|
17133
|
-
def one_of(self) -> _builtins.str:
|
|
17134
|
-
"""
|
|
17135
|
-
A list of acceptable single values for the field.
|
|
17136
|
-
"""
|
|
17137
|
-
return pulumi.get(self, "one_of")
|
|
17138
|
-
|
|
17139
|
-
@one_of.setter
|
|
17140
|
-
def one_of(self, value: _builtins.str):
|
|
17141
|
-
pulumi.set(self, "one_of", value)
|
|
17142
|
-
|
|
17143
|
-
|
|
17144
|
-
if not MYPY:
|
|
17145
|
-
class GetUserDatabaseGrantArgsDict(TypedDict):
|
|
17146
|
-
id: _builtins.int
|
|
17147
|
-
"""
|
|
17148
|
-
The ID of entity this grant applies to.
|
|
17149
|
-
"""
|
|
17150
|
-
label: _builtins.str
|
|
17151
|
-
"""
|
|
17152
|
-
The current label of the entity this grant applies to, for display purposes.
|
|
17153
|
-
"""
|
|
17154
|
-
permissions: _builtins.str
|
|
17155
|
-
"""
|
|
17156
|
-
The level of access this User has to this entity. If null, this User has no access. (`read_only`, `read_write`)
|
|
17157
|
-
"""
|
|
17158
|
-
elif False:
|
|
17159
|
-
GetUserDatabaseGrantArgsDict: TypeAlias = Mapping[str, Any]
|
|
17160
|
-
|
|
17161
|
-
@pulumi.input_type
|
|
17162
|
-
class GetUserDatabaseGrantArgs:
|
|
17163
|
-
def __init__(__self__, *,
|
|
17164
|
-
id: _builtins.int,
|
|
17165
|
-
label: _builtins.str,
|
|
17166
|
-
permissions: _builtins.str):
|
|
17167
|
-
"""
|
|
17168
|
-
:param _builtins.int id: The ID of entity this grant applies to.
|
|
17169
|
-
:param _builtins.str label: The current label of the entity this grant applies to, for display purposes.
|
|
17170
|
-
: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`)
|
|
17171
|
-
"""
|
|
17172
|
-
pulumi.set(__self__, "id", id)
|
|
17173
|
-
pulumi.set(__self__, "label", label)
|
|
17174
|
-
pulumi.set(__self__, "permissions", permissions)
|
|
17175
|
-
|
|
17176
|
-
@_builtins.property
|
|
17177
|
-
@pulumi.getter
|
|
17178
|
-
def id(self) -> _builtins.int:
|
|
17179
|
-
"""
|
|
17180
|
-
The ID of entity this grant applies to.
|
|
17181
|
-
"""
|
|
17182
|
-
return pulumi.get(self, "id")
|
|
17183
|
-
|
|
17184
|
-
@id.setter
|
|
17185
|
-
def id(self, value: _builtins.int):
|
|
17186
|
-
pulumi.set(self, "id", value)
|
|
17187
|
-
|
|
17188
|
-
@_builtins.property
|
|
17189
|
-
@pulumi.getter
|
|
17190
|
-
def label(self) -> _builtins.str:
|
|
17998
|
+
def name(self) -> _builtins.str:
|
|
17191
17999
|
"""
|
|
17192
|
-
The
|
|
18000
|
+
The name of the field.
|
|
17193
18001
|
"""
|
|
17194
|
-
return pulumi.get(self, "
|
|
18002
|
+
return pulumi.get(self, "name")
|
|
17195
18003
|
|
|
17196
|
-
@
|
|
17197
|
-
def
|
|
17198
|
-
pulumi.set(self, "
|
|
18004
|
+
@name.setter
|
|
18005
|
+
def name(self, value: _builtins.str):
|
|
18006
|
+
pulumi.set(self, "name", value)
|
|
17199
18007
|
|
|
17200
18008
|
@_builtins.property
|
|
17201
|
-
@pulumi.getter
|
|
17202
|
-
def
|
|
18009
|
+
@pulumi.getter(name="oneOf")
|
|
18010
|
+
def one_of(self) -> _builtins.str:
|
|
17203
18011
|
"""
|
|
17204
|
-
|
|
18012
|
+
A list of acceptable single values for the field.
|
|
17205
18013
|
"""
|
|
17206
|
-
return pulumi.get(self, "
|
|
18014
|
+
return pulumi.get(self, "one_of")
|
|
17207
18015
|
|
|
17208
|
-
@
|
|
17209
|
-
def
|
|
17210
|
-
pulumi.set(self, "
|
|
18016
|
+
@one_of.setter
|
|
18017
|
+
def one_of(self, value: _builtins.str):
|
|
18018
|
+
pulumi.set(self, "one_of", value)
|
|
17211
18019
|
|
|
17212
18020
|
|
|
17213
18021
|
if not MYPY:
|
|
17214
|
-
class
|
|
18022
|
+
class GetUserDatabaseGrantArgsDict(TypedDict):
|
|
17215
18023
|
id: _builtins.int
|
|
17216
18024
|
"""
|
|
17217
18025
|
The ID of entity this grant applies to.
|
|
@@ -17225,10 +18033,10 @@ if not MYPY:
|
|
|
17225
18033
|
The level of access this User has to this entity. If null, this User has no access. (`read_only`, `read_write`)
|
|
17226
18034
|
"""
|
|
17227
18035
|
elif False:
|
|
17228
|
-
|
|
18036
|
+
GetUserDatabaseGrantArgsDict: TypeAlias = Mapping[str, Any]
|
|
17229
18037
|
|
|
17230
18038
|
@pulumi.input_type
|
|
17231
|
-
class
|
|
18039
|
+
class GetUserDatabaseGrantArgs:
|
|
17232
18040
|
def __init__(__self__, *,
|
|
17233
18041
|
id: _builtins.int,
|
|
17234
18042
|
label: _builtins.str,
|
|
@@ -17280,7 +18088,7 @@ class GetUserDomainGrantArgs:
|
|
|
17280
18088
|
|
|
17281
18089
|
|
|
17282
18090
|
if not MYPY:
|
|
17283
|
-
class
|
|
18091
|
+
class GetUserDomainGrantArgsDict(TypedDict):
|
|
17284
18092
|
id: _builtins.int
|
|
17285
18093
|
"""
|
|
17286
18094
|
The ID of entity this grant applies to.
|
|
@@ -17294,10 +18102,10 @@ if not MYPY:
|
|
|
17294
18102
|
The level of access this User has to this entity. If null, this User has no access. (`read_only`, `read_write`)
|
|
17295
18103
|
"""
|
|
17296
18104
|
elif False:
|
|
17297
|
-
|
|
18105
|
+
GetUserDomainGrantArgsDict: TypeAlias = Mapping[str, Any]
|
|
17298
18106
|
|
|
17299
18107
|
@pulumi.input_type
|
|
17300
|
-
class
|
|
18108
|
+
class GetUserDomainGrantArgs:
|
|
17301
18109
|
def __init__(__self__, *,
|
|
17302
18110
|
id: _builtins.int,
|
|
17303
18111
|
label: _builtins.str,
|
|
@@ -17349,7 +18157,7 @@ class GetUserFirewallGrantArgs:
|
|
|
17349
18157
|
|
|
17350
18158
|
|
|
17351
18159
|
if not MYPY:
|
|
17352
|
-
class
|
|
18160
|
+
class GetUserFirewallGrantArgsDict(TypedDict):
|
|
17353
18161
|
id: _builtins.int
|
|
17354
18162
|
"""
|
|
17355
18163
|
The ID of entity this grant applies to.
|
|
@@ -17363,10 +18171,10 @@ if not MYPY:
|
|
|
17363
18171
|
The level of access this User has to this entity. If null, this User has no access. (`read_only`, `read_write`)
|
|
17364
18172
|
"""
|
|
17365
18173
|
elif False:
|
|
17366
|
-
|
|
18174
|
+
GetUserFirewallGrantArgsDict: TypeAlias = Mapping[str, Any]
|
|
17367
18175
|
|
|
17368
18176
|
@pulumi.input_type
|
|
17369
|
-
class
|
|
18177
|
+
class GetUserFirewallGrantArgs:
|
|
17370
18178
|
def __init__(__self__, *,
|
|
17371
18179
|
id: _builtins.int,
|
|
17372
18180
|
label: _builtins.str,
|
|
@@ -17418,7 +18226,7 @@ class GetUserImageGrantArgs:
|
|
|
17418
18226
|
|
|
17419
18227
|
|
|
17420
18228
|
if not MYPY:
|
|
17421
|
-
class
|
|
18229
|
+
class GetUserImageGrantArgsDict(TypedDict):
|
|
17422
18230
|
id: _builtins.int
|
|
17423
18231
|
"""
|
|
17424
18232
|
The ID of entity this grant applies to.
|
|
@@ -17432,10 +18240,10 @@ if not MYPY:
|
|
|
17432
18240
|
The level of access this User has to this entity. If null, this User has no access. (`read_only`, `read_write`)
|
|
17433
18241
|
"""
|
|
17434
18242
|
elif False:
|
|
17435
|
-
|
|
18243
|
+
GetUserImageGrantArgsDict: TypeAlias = Mapping[str, Any]
|
|
17436
18244
|
|
|
17437
18245
|
@pulumi.input_type
|
|
17438
|
-
class
|
|
18246
|
+
class GetUserImageGrantArgs:
|
|
17439
18247
|
def __init__(__self__, *,
|
|
17440
18248
|
id: _builtins.int,
|
|
17441
18249
|
label: _builtins.str,
|
|
@@ -17487,7 +18295,7 @@ class GetUserLinodeGrantArgs:
|
|
|
17487
18295
|
|
|
17488
18296
|
|
|
17489
18297
|
if not MYPY:
|
|
17490
|
-
class
|
|
18298
|
+
class GetUserLinodeGrantArgsDict(TypedDict):
|
|
17491
18299
|
id: _builtins.int
|
|
17492
18300
|
"""
|
|
17493
18301
|
The ID of entity this grant applies to.
|
|
@@ -17501,10 +18309,10 @@ if not MYPY:
|
|
|
17501
18309
|
The level of access this User has to this entity. If null, this User has no access. (`read_only`, `read_write`)
|
|
17502
18310
|
"""
|
|
17503
18311
|
elif False:
|
|
17504
|
-
|
|
18312
|
+
GetUserLinodeGrantArgsDict: TypeAlias = Mapping[str, Any]
|
|
17505
18313
|
|
|
17506
18314
|
@pulumi.input_type
|
|
17507
|
-
class
|
|
18315
|
+
class GetUserLinodeGrantArgs:
|
|
17508
18316
|
def __init__(__self__, *,
|
|
17509
18317
|
id: _builtins.int,
|
|
17510
18318
|
label: _builtins.str,
|
|
@@ -17556,7 +18364,7 @@ class GetUserLongviewGrantArgs:
|
|
|
17556
18364
|
|
|
17557
18365
|
|
|
17558
18366
|
if not MYPY:
|
|
17559
|
-
class
|
|
18367
|
+
class GetUserLongviewGrantArgsDict(TypedDict):
|
|
17560
18368
|
id: _builtins.int
|
|
17561
18369
|
"""
|
|
17562
18370
|
The ID of entity this grant applies to.
|
|
@@ -17570,10 +18378,10 @@ if not MYPY:
|
|
|
17570
18378
|
The level of access this User has to this entity. If null, this User has no access. (`read_only`, `read_write`)
|
|
17571
18379
|
"""
|
|
17572
18380
|
elif False:
|
|
17573
|
-
|
|
18381
|
+
GetUserLongviewGrantArgsDict: TypeAlias = Mapping[str, Any]
|
|
17574
18382
|
|
|
17575
18383
|
@pulumi.input_type
|
|
17576
|
-
class
|
|
18384
|
+
class GetUserLongviewGrantArgs:
|
|
17577
18385
|
def __init__(__self__, *,
|
|
17578
18386
|
id: _builtins.int,
|
|
17579
18387
|
label: _builtins.str,
|
|
@@ -17625,7 +18433,7 @@ class GetUserNodebalancerGrantArgs:
|
|
|
17625
18433
|
|
|
17626
18434
|
|
|
17627
18435
|
if not MYPY:
|
|
17628
|
-
class
|
|
18436
|
+
class GetUserNodebalancerGrantArgsDict(TypedDict):
|
|
17629
18437
|
id: _builtins.int
|
|
17630
18438
|
"""
|
|
17631
18439
|
The ID of entity this grant applies to.
|
|
@@ -17639,10 +18447,10 @@ if not MYPY:
|
|
|
17639
18447
|
The level of access this User has to this entity. If null, this User has no access. (`read_only`, `read_write`)
|
|
17640
18448
|
"""
|
|
17641
18449
|
elif False:
|
|
17642
|
-
|
|
18450
|
+
GetUserNodebalancerGrantArgsDict: TypeAlias = Mapping[str, Any]
|
|
17643
18451
|
|
|
17644
18452
|
@pulumi.input_type
|
|
17645
|
-
class
|
|
18453
|
+
class GetUserNodebalancerGrantArgs:
|
|
17646
18454
|
def __init__(__self__, *,
|
|
17647
18455
|
id: _builtins.int,
|
|
17648
18456
|
label: _builtins.str,
|
|
@@ -18016,10 +18824,6 @@ if not MYPY:
|
|
|
18016
18824
|
"""
|
|
18017
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.
|
|
18018
18826
|
"""
|
|
18019
|
-
placement_group_grants: Sequence['GetUsersUserPlacementGroupGrantArgsDict']
|
|
18020
|
-
"""
|
|
18021
|
-
A set containing all of the user's active grants.
|
|
18022
|
-
"""
|
|
18023
18827
|
restricted: _builtins.bool
|
|
18024
18828
|
"""
|
|
18025
18829
|
If true, this User must be granted access to perform actions or access entities on this Account.
|
|
@@ -18073,7 +18877,6 @@ class GetUsersUserArgs:
|
|
|
18073
18877
|
longview_grants: Sequence['GetUsersUserLongviewGrantArgs'],
|
|
18074
18878
|
nodebalancer_grants: Sequence['GetUsersUserNodebalancerGrantArgs'],
|
|
18075
18879
|
password_created: _builtins.str,
|
|
18076
|
-
placement_group_grants: Sequence['GetUsersUserPlacementGroupGrantArgs'],
|
|
18077
18880
|
restricted: _builtins.bool,
|
|
18078
18881
|
ssh_keys: Sequence[_builtins.str],
|
|
18079
18882
|
stackscript_grants: Sequence['GetUsersUserStackscriptGrantArgs'],
|
|
@@ -18095,7 +18898,6 @@ class GetUsersUserArgs:
|
|
|
18095
18898
|
:param Sequence['GetUsersUserLongviewGrantArgs'] longview_grants: A set containing all of the user's active grants.
|
|
18096
18899
|
:param Sequence['GetUsersUserNodebalancerGrantArgs'] nodebalancer_grants: A set containing all of the user's active grants.
|
|
18097
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.
|
|
18098
|
-
:param Sequence['GetUsersUserPlacementGroupGrantArgs'] placement_group_grants: A set containing all of the user's active grants.
|
|
18099
18901
|
:param _builtins.bool restricted: If true, this User must be granted access to perform actions or access entities on this Account.
|
|
18100
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.
|
|
18101
18903
|
:param Sequence['GetUsersUserStackscriptGrantArgs'] stackscript_grants: A set containing all of the user's active grants.
|
|
@@ -18117,7 +18919,6 @@ class GetUsersUserArgs:
|
|
|
18117
18919
|
pulumi.set(__self__, "longview_grants", longview_grants)
|
|
18118
18920
|
pulumi.set(__self__, "nodebalancer_grants", nodebalancer_grants)
|
|
18119
18921
|
pulumi.set(__self__, "password_created", password_created)
|
|
18120
|
-
pulumi.set(__self__, "placement_group_grants", placement_group_grants)
|
|
18121
18922
|
pulumi.set(__self__, "restricted", restricted)
|
|
18122
18923
|
pulumi.set(__self__, "ssh_keys", ssh_keys)
|
|
18123
18924
|
pulumi.set(__self__, "stackscript_grants", stackscript_grants)
|
|
@@ -18260,18 +19061,6 @@ class GetUsersUserArgs:
|
|
|
18260
19061
|
def password_created(self, value: _builtins.str):
|
|
18261
19062
|
pulumi.set(self, "password_created", value)
|
|
18262
19063
|
|
|
18263
|
-
@_builtins.property
|
|
18264
|
-
@pulumi.getter(name="placementGroupGrants")
|
|
18265
|
-
def placement_group_grants(self) -> Sequence['GetUsersUserPlacementGroupGrantArgs']:
|
|
18266
|
-
"""
|
|
18267
|
-
A set containing all of the user's active grants.
|
|
18268
|
-
"""
|
|
18269
|
-
return pulumi.get(self, "placement_group_grants")
|
|
18270
|
-
|
|
18271
|
-
@placement_group_grants.setter
|
|
18272
|
-
def placement_group_grants(self, value: Sequence['GetUsersUserPlacementGroupGrantArgs']):
|
|
18273
|
-
pulumi.set(self, "placement_group_grants", value)
|
|
18274
|
-
|
|
18275
19064
|
@_builtins.property
|
|
18276
19065
|
@pulumi.getter
|
|
18277
19066
|
def restricted(self) -> _builtins.bool:
|
|
@@ -18622,10 +19411,6 @@ if not MYPY:
|
|
|
18622
19411
|
"""
|
|
18623
19412
|
If true, this User may add NodeBalancers.
|
|
18624
19413
|
"""
|
|
18625
|
-
add_placement_groups: _builtins.bool
|
|
18626
|
-
"""
|
|
18627
|
-
If true, this User may add Placement Groups.
|
|
18628
|
-
"""
|
|
18629
19414
|
add_stackscripts: _builtins.bool
|
|
18630
19415
|
add_volumes: _builtins.bool
|
|
18631
19416
|
"""
|
|
@@ -18657,7 +19442,6 @@ class GetUsersUserGlobalGrantArgs:
|
|
|
18657
19442
|
add_linodes: _builtins.bool,
|
|
18658
19443
|
add_longview: _builtins.bool,
|
|
18659
19444
|
add_nodebalancers: _builtins.bool,
|
|
18660
|
-
add_placement_groups: _builtins.bool,
|
|
18661
19445
|
add_stackscripts: _builtins.bool,
|
|
18662
19446
|
add_volumes: _builtins.bool,
|
|
18663
19447
|
add_vpcs: _builtins.bool,
|
|
@@ -18672,7 +19456,6 @@ class GetUsersUserGlobalGrantArgs:
|
|
|
18672
19456
|
:param _builtins.bool add_linodes: If true, this User may create Linodes.
|
|
18673
19457
|
:param _builtins.bool add_longview: If true, this User may create Longview clients and view the current plan.
|
|
18674
19458
|
:param _builtins.bool add_nodebalancers: If true, this User may add NodeBalancers.
|
|
18675
|
-
:param _builtins.bool add_placement_groups: If true, this User may add Placement Groups.
|
|
18676
19459
|
:param _builtins.bool add_volumes: If true, this User may add Volumes.
|
|
18677
19460
|
:param _builtins.bool add_vpcs: If true, this User may add Virtual Private Clouds (VPCs).
|
|
18678
19461
|
:param _builtins.bool cancel_account: If true, this User may cancel the entire Account.
|
|
@@ -18686,7 +19469,6 @@ class GetUsersUserGlobalGrantArgs:
|
|
|
18686
19469
|
pulumi.set(__self__, "add_linodes", add_linodes)
|
|
18687
19470
|
pulumi.set(__self__, "add_longview", add_longview)
|
|
18688
19471
|
pulumi.set(__self__, "add_nodebalancers", add_nodebalancers)
|
|
18689
|
-
pulumi.set(__self__, "add_placement_groups", add_placement_groups)
|
|
18690
19472
|
pulumi.set(__self__, "add_stackscripts", add_stackscripts)
|
|
18691
19473
|
pulumi.set(__self__, "add_volumes", add_volumes)
|
|
18692
19474
|
pulumi.set(__self__, "add_vpcs", add_vpcs)
|
|
@@ -18789,18 +19571,6 @@ class GetUsersUserGlobalGrantArgs:
|
|
|
18789
19571
|
def add_nodebalancers(self, value: _builtins.bool):
|
|
18790
19572
|
pulumi.set(self, "add_nodebalancers", value)
|
|
18791
19573
|
|
|
18792
|
-
@_builtins.property
|
|
18793
|
-
@pulumi.getter(name="addPlacementGroups")
|
|
18794
|
-
def add_placement_groups(self) -> _builtins.bool:
|
|
18795
|
-
"""
|
|
18796
|
-
If true, this User may add Placement Groups.
|
|
18797
|
-
"""
|
|
18798
|
-
return pulumi.get(self, "add_placement_groups")
|
|
18799
|
-
|
|
18800
|
-
@add_placement_groups.setter
|
|
18801
|
-
def add_placement_groups(self, value: _builtins.bool):
|
|
18802
|
-
pulumi.set(self, "add_placement_groups", value)
|
|
18803
|
-
|
|
18804
19574
|
@_builtins.property
|
|
18805
19575
|
@pulumi.getter(name="addStackscripts")
|
|
18806
19576
|
def add_stackscripts(self) -> _builtins.bool:
|
|
@@ -19135,75 +19905,6 @@ class GetUsersUserNodebalancerGrantArgs:
|
|
|
19135
19905
|
pulumi.set(self, "permissions", value)
|
|
19136
19906
|
|
|
19137
19907
|
|
|
19138
|
-
if not MYPY:
|
|
19139
|
-
class GetUsersUserPlacementGroupGrantArgsDict(TypedDict):
|
|
19140
|
-
id: _builtins.int
|
|
19141
|
-
"""
|
|
19142
|
-
The ID of entity this grant applies to.
|
|
19143
|
-
"""
|
|
19144
|
-
label: _builtins.str
|
|
19145
|
-
"""
|
|
19146
|
-
The current label of the entity this grant applies to, for display purposes.
|
|
19147
|
-
"""
|
|
19148
|
-
permissions: _builtins.str
|
|
19149
|
-
"""
|
|
19150
|
-
The level of access this User has to this entity. If null, this User has no access.
|
|
19151
|
-
"""
|
|
19152
|
-
elif False:
|
|
19153
|
-
GetUsersUserPlacementGroupGrantArgsDict: TypeAlias = Mapping[str, Any]
|
|
19154
|
-
|
|
19155
|
-
@pulumi.input_type
|
|
19156
|
-
class GetUsersUserPlacementGroupGrantArgs:
|
|
19157
|
-
def __init__(__self__, *,
|
|
19158
|
-
id: _builtins.int,
|
|
19159
|
-
label: _builtins.str,
|
|
19160
|
-
permissions: _builtins.str):
|
|
19161
|
-
"""
|
|
19162
|
-
:param _builtins.int id: The ID of entity this grant applies to.
|
|
19163
|
-
:param _builtins.str label: The current label of the entity this grant applies to, for display purposes.
|
|
19164
|
-
:param _builtins.str permissions: The level of access this User has to this entity. If null, this User has no access.
|
|
19165
|
-
"""
|
|
19166
|
-
pulumi.set(__self__, "id", id)
|
|
19167
|
-
pulumi.set(__self__, "label", label)
|
|
19168
|
-
pulumi.set(__self__, "permissions", permissions)
|
|
19169
|
-
|
|
19170
|
-
@_builtins.property
|
|
19171
|
-
@pulumi.getter
|
|
19172
|
-
def id(self) -> _builtins.int:
|
|
19173
|
-
"""
|
|
19174
|
-
The ID of entity this grant applies to.
|
|
19175
|
-
"""
|
|
19176
|
-
return pulumi.get(self, "id")
|
|
19177
|
-
|
|
19178
|
-
@id.setter
|
|
19179
|
-
def id(self, value: _builtins.int):
|
|
19180
|
-
pulumi.set(self, "id", value)
|
|
19181
|
-
|
|
19182
|
-
@_builtins.property
|
|
19183
|
-
@pulumi.getter
|
|
19184
|
-
def label(self) -> _builtins.str:
|
|
19185
|
-
"""
|
|
19186
|
-
The current label of the entity this grant applies to, for display purposes.
|
|
19187
|
-
"""
|
|
19188
|
-
return pulumi.get(self, "label")
|
|
19189
|
-
|
|
19190
|
-
@label.setter
|
|
19191
|
-
def label(self, value: _builtins.str):
|
|
19192
|
-
pulumi.set(self, "label", value)
|
|
19193
|
-
|
|
19194
|
-
@_builtins.property
|
|
19195
|
-
@pulumi.getter
|
|
19196
|
-
def permissions(self) -> _builtins.str:
|
|
19197
|
-
"""
|
|
19198
|
-
The level of access this User has to this entity. If null, this User has no access.
|
|
19199
|
-
"""
|
|
19200
|
-
return pulumi.get(self, "permissions")
|
|
19201
|
-
|
|
19202
|
-
@permissions.setter
|
|
19203
|
-
def permissions(self, value: _builtins.str):
|
|
19204
|
-
pulumi.set(self, "permissions", value)
|
|
19205
|
-
|
|
19206
|
-
|
|
19207
19908
|
if not MYPY:
|
|
19208
19909
|
class GetUsersUserStackscriptGrantArgsDict(TypedDict):
|
|
19209
19910
|
id: _builtins.int
|
|
@@ -20238,6 +20939,18 @@ if not MYPY:
|
|
|
20238
20939
|
"""
|
|
20239
20940
|
The globally general API entity identifier for the Linode interface.
|
|
20240
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
|
+
"""
|
|
20241
20954
|
linode_id: _builtins.int
|
|
20242
20955
|
"""
|
|
20243
20956
|
The identifier for the Linode the VPC interface currently belongs to.
|
|
@@ -20280,6 +20993,9 @@ class GetVpcIpsVpcIpArgs:
|
|
|
20280
20993
|
config_id: _builtins.int,
|
|
20281
20994
|
gateway: _builtins.str,
|
|
20282
20995
|
interface_id: _builtins.int,
|
|
20996
|
+
ipv6_addresses: Sequence['GetVpcIpsVpcIpIpv6AddressArgs'],
|
|
20997
|
+
ipv6_is_public: _builtins.bool,
|
|
20998
|
+
ipv6_range: _builtins.str,
|
|
20283
20999
|
linode_id: _builtins.int,
|
|
20284
21000
|
nat11: _builtins.str,
|
|
20285
21001
|
prefix: _builtins.int,
|
|
@@ -20294,6 +21010,9 @@ class GetVpcIpsVpcIpArgs:
|
|
|
20294
21010
|
:param _builtins.int config_id: The globally general entity identifier for the Linode configuration profile where the VPC is included.
|
|
20295
21011
|
:param _builtins.str gateway: The default gateway for the VPC subnet that the IP or IP range belongs to.
|
|
20296
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.
|
|
20297
21016
|
:param _builtins.int linode_id: The identifier for the Linode the VPC interface currently belongs to.
|
|
20298
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.
|
|
20299
21018
|
:param _builtins.int prefix: The number of bits set in the subnet mask.
|
|
@@ -20310,6 +21029,9 @@ class GetVpcIpsVpcIpArgs:
|
|
|
20310
21029
|
pulumi.set(__self__, "config_id", config_id)
|
|
20311
21030
|
pulumi.set(__self__, "gateway", gateway)
|
|
20312
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)
|
|
20313
21035
|
pulumi.set(__self__, "linode_id", linode_id)
|
|
20314
21036
|
pulumi.set(__self__, "nat11", nat11)
|
|
20315
21037
|
pulumi.set(__self__, "prefix", prefix)
|
|
@@ -20390,6 +21112,42 @@ class GetVpcIpsVpcIpArgs:
|
|
|
20390
21112
|
def interface_id(self, value: _builtins.int):
|
|
20391
21113
|
pulumi.set(self, "interface_id", value)
|
|
20392
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
|
+
|
|
20393
21151
|
@_builtins.property
|
|
20394
21152
|
@pulumi.getter(name="linodeId")
|
|
20395
21153
|
def linode_id(self) -> _builtins.int:
|
|
@@ -20477,6 +21235,37 @@ class GetVpcIpsVpcIpArgs:
|
|
|
20477
21235
|
pulumi.set(self, "vpc_id", value)
|
|
20478
21236
|
|
|
20479
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
|
+
|
|
20480
21269
|
if not MYPY:
|
|
20481
21270
|
class GetVpcSubnetsFilterArgsDict(TypedDict):
|
|
20482
21271
|
name: _builtins.str
|
|
@@ -20561,6 +21350,10 @@ if not MYPY:
|
|
|
20561
21350
|
"""
|
|
20562
21351
|
The IPv4 range of this subnet in CIDR format.
|
|
20563
21352
|
"""
|
|
21353
|
+
ipv6s: Sequence['GetVpcSubnetsVpcSubnetIpv6ArgsDict']
|
|
21354
|
+
"""
|
|
21355
|
+
The IPv6 ranges of this subnet.
|
|
21356
|
+
"""
|
|
20564
21357
|
label: _builtins.str
|
|
20565
21358
|
"""
|
|
20566
21359
|
The label of the VPC subnet.
|
|
@@ -20582,6 +21375,7 @@ class GetVpcSubnetsVpcSubnetArgs:
|
|
|
20582
21375
|
created: _builtins.str,
|
|
20583
21376
|
id: _builtins.int,
|
|
20584
21377
|
ipv4: _builtins.str,
|
|
21378
|
+
ipv6s: Sequence['GetVpcSubnetsVpcSubnetIpv6Args'],
|
|
20585
21379
|
label: _builtins.str,
|
|
20586
21380
|
linodes: Sequence['GetVpcSubnetsVpcSubnetLinodeArgs'],
|
|
20587
21381
|
updated: _builtins.str):
|
|
@@ -20589,6 +21383,7 @@ class GetVpcSubnetsVpcSubnetArgs:
|
|
|
20589
21383
|
:param _builtins.str created: The date and time when the VPC Subnet was created.
|
|
20590
21384
|
:param _builtins.int id: The unique id of the VPC subnet.
|
|
20591
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.
|
|
20592
21387
|
:param _builtins.str label: The label of the VPC subnet.
|
|
20593
21388
|
:param Sequence['GetVpcSubnetsVpcSubnetLinodeArgs'] linodes: A list of Linode IDs that added to this subnet.
|
|
20594
21389
|
:param _builtins.str updated: The date and time when the VPC Subnet was last updated.
|
|
@@ -20596,6 +21391,7 @@ class GetVpcSubnetsVpcSubnetArgs:
|
|
|
20596
21391
|
pulumi.set(__self__, "created", created)
|
|
20597
21392
|
pulumi.set(__self__, "id", id)
|
|
20598
21393
|
pulumi.set(__self__, "ipv4", ipv4)
|
|
21394
|
+
pulumi.set(__self__, "ipv6s", ipv6s)
|
|
20599
21395
|
pulumi.set(__self__, "label", label)
|
|
20600
21396
|
pulumi.set(__self__, "linodes", linodes)
|
|
20601
21397
|
pulumi.set(__self__, "updated", updated)
|
|
@@ -20636,6 +21432,18 @@ class GetVpcSubnetsVpcSubnetArgs:
|
|
|
20636
21432
|
def ipv4(self, value: _builtins.str):
|
|
20637
21433
|
pulumi.set(self, "ipv4", value)
|
|
20638
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
|
+
|
|
20639
21447
|
@_builtins.property
|
|
20640
21448
|
@pulumi.getter
|
|
20641
21449
|
def label(self) -> _builtins.str:
|
|
@@ -20673,6 +21481,37 @@ class GetVpcSubnetsVpcSubnetArgs:
|
|
|
20673
21481
|
pulumi.set(self, "updated", value)
|
|
20674
21482
|
|
|
20675
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
|
+
|
|
20676
21515
|
if not MYPY:
|
|
20677
21516
|
class GetVpcSubnetsVpcSubnetLinodeArgsDict(TypedDict):
|
|
20678
21517
|
id: _builtins.int
|
|
@@ -20843,6 +21682,10 @@ if not MYPY:
|
|
|
20843
21682
|
"""
|
|
20844
21683
|
The unique id of this VPC.
|
|
20845
21684
|
"""
|
|
21685
|
+
ipv6s: Sequence['GetVpcsVpcIpv6ArgsDict']
|
|
21686
|
+
"""
|
|
21687
|
+
A list of IPv6 allocations under this VPC.
|
|
21688
|
+
"""
|
|
20846
21689
|
label: _builtins.str
|
|
20847
21690
|
"""
|
|
20848
21691
|
The label of the VPC.
|
|
@@ -20864,6 +21707,7 @@ class GetVpcsVpcArgs:
|
|
|
20864
21707
|
created: _builtins.str,
|
|
20865
21708
|
description: _builtins.str,
|
|
20866
21709
|
id: _builtins.str,
|
|
21710
|
+
ipv6s: Sequence['GetVpcsVpcIpv6Args'],
|
|
20867
21711
|
label: _builtins.str,
|
|
20868
21712
|
region: _builtins.str,
|
|
20869
21713
|
updated: _builtins.str):
|
|
@@ -20871,6 +21715,7 @@ class GetVpcsVpcArgs:
|
|
|
20871
21715
|
:param _builtins.str created: The date and time when the VPC was created.
|
|
20872
21716
|
:param _builtins.str description: The user-defined description of this VPC.
|
|
20873
21717
|
:param _builtins.str id: The unique id of this VPC.
|
|
21718
|
+
:param Sequence['GetVpcsVpcIpv6Args'] ipv6s: A list of IPv6 allocations under this VPC.
|
|
20874
21719
|
:param _builtins.str label: The label of the VPC.
|
|
20875
21720
|
:param _builtins.str region: The region where the VPC is deployed.
|
|
20876
21721
|
:param _builtins.str updated: The date and time when the VPC was last updated.
|
|
@@ -20878,6 +21723,7 @@ class GetVpcsVpcArgs:
|
|
|
20878
21723
|
pulumi.set(__self__, "created", created)
|
|
20879
21724
|
pulumi.set(__self__, "description", description)
|
|
20880
21725
|
pulumi.set(__self__, "id", id)
|
|
21726
|
+
pulumi.set(__self__, "ipv6s", ipv6s)
|
|
20881
21727
|
pulumi.set(__self__, "label", label)
|
|
20882
21728
|
pulumi.set(__self__, "region", region)
|
|
20883
21729
|
pulumi.set(__self__, "updated", updated)
|
|
@@ -20918,6 +21764,18 @@ class GetVpcsVpcArgs:
|
|
|
20918
21764
|
def id(self, value: _builtins.str):
|
|
20919
21765
|
pulumi.set(self, "id", value)
|
|
20920
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
|
+
|
|
20921
21779
|
@_builtins.property
|
|
20922
21780
|
@pulumi.getter
|
|
20923
21781
|
def label(self) -> _builtins.str:
|
|
@@ -20955,3 +21813,34 @@ class GetVpcsVpcArgs:
|
|
|
20955
21813
|
pulumi.set(self, "updated", value)
|
|
20956
21814
|
|
|
20957
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
|
+
|