pulumi-linode 5.3.0a1757052548__py3-none-any.whl → 5.4.0__py3-none-any.whl

pulumi_linode/get_lke_cluster.py

@@ -28,7 +28,7 @@ class GetLkeClusterResult:
     """
     A collection of values returned by getLkeCluster.
     """
-    def __init__(__self__, api_endpoints=None, apl_enabled=None, control_planes=None, created=None, dashboard_url=None, id=None, k8s_version=None, kubeconfig=None, label=None, pools=None, region=None, status=None, tags=None, tier=None, updated=None):
+    def __init__(__self__, api_endpoints=None, apl_enabled=None, control_planes=None, created=None, dashboard_url=None, id=None, k8s_version=None, kubeconfig=None, label=None, pools=None, region=None, stack_type=None, status=None, subnet_id=None, tags=None, tier=None, updated=None, vpc_id=None):
         if api_endpoints and not isinstance(api_endpoints, list):
             raise TypeError("Expected argument 'api_endpoints' to be a list")
         pulumi.set(__self__, "api_endpoints", api_endpoints)
@@ -62,9 +62,15 @@ class GetLkeClusterResult:
         if region and not isinstance(region, str):
             raise TypeError("Expected argument 'region' to be a str")
         pulumi.set(__self__, "region", region)
+        if stack_type and not isinstance(stack_type, str):
+            raise TypeError("Expected argument 'stack_type' to be a str")
+        pulumi.set(__self__, "stack_type", stack_type)
         if status and not isinstance(status, str):
             raise TypeError("Expected argument 'status' to be a str")
         pulumi.set(__self__, "status", status)
+        if subnet_id and not isinstance(subnet_id, int):
+            raise TypeError("Expected argument 'subnet_id' to be a int")
+        pulumi.set(__self__, "subnet_id", subnet_id)
         if tags and not isinstance(tags, list):
             raise TypeError("Expected argument 'tags' to be a list")
         pulumi.set(__self__, "tags", tags)
@@ -74,6 +80,9 @@ class GetLkeClusterResult:
         if updated and not isinstance(updated, str):
             raise TypeError("Expected argument 'updated' to be a str")
         pulumi.set(__self__, "updated", updated)
+        if vpc_id and not isinstance(vpc_id, int):
+            raise TypeError("Expected argument 'vpc_id' to be a int")
+        pulumi.set(__self__, "vpc_id", vpc_id)
 
     @_builtins.property
     @pulumi.getter(name="apiEndpoints")
@@ -163,6 +172,14 @@ class GetLkeClusterResult:
         """
         return pulumi.get(self, "region")
 
+    @_builtins.property
+    @pulumi.getter(name="stackType")
+    def stack_type(self) -> _builtins.str:
+        """
+        The networking stack type of the Kubernetes cluster.
+        """
+        return pulumi.get(self, "stack_type")
+
     @_builtins.property
     @pulumi.getter
     def status(self) -> _builtins.str:
@@ -171,6 +188,14 @@ class GetLkeClusterResult:
         """
         return pulumi.get(self, "status")
 
+    @_builtins.property
+    @pulumi.getter(name="subnetId")
+    def subnet_id(self) -> _builtins.int:
+        """
+        The ID of the VPC subnet to use for the Kubernetes cluster. This subnet must be dual stack (IPv4 and IPv6 should both be enabled).
+        """
+        return pulumi.get(self, "subnet_id")
+
     @_builtins.property
     @pulumi.getter
     def tags(self) -> Sequence[_builtins.str]:
@@ -195,6 +220,14 @@ class GetLkeClusterResult:
         """
         return pulumi.get(self, "updated")
 
+    @_builtins.property
+    @pulumi.getter(name="vpcId")
+    def vpc_id(self) -> _builtins.int:
+        """
+        The ID of the VPC to use for the Kubernetes cluster.
+        """
+        return pulumi.get(self, "vpc_id")
+
 
 class AwaitableGetLkeClusterResult(GetLkeClusterResult):
     # pylint: disable=using-constant-test
@@ -213,10 +246,13 @@ class AwaitableGetLkeClusterResult(GetLkeClusterResult):
             label=self.label,
             pools=self.pools,
             region=self.region,
+            stack_type=self.stack_type,
             status=self.status,
+            subnet_id=self.subnet_id,
             tags=self.tags,
             tier=self.tier,
-            updated=self.updated)
+            updated=self.updated,
+            vpc_id=self.vpc_id)
 
 
 def get_lke_cluster(control_planes: Optional[Sequence[Union['GetLkeClusterControlPlaneArgs', 'GetLkeClusterControlPlaneArgsDict']]] = None,
@@ -260,10 +296,13 @@ def get_lke_cluster(control_planes: Optional[Sequence[Union['GetLkeClusterContro
         label=pulumi.get(__ret__, 'label'),
         pools=pulumi.get(__ret__, 'pools'),
         region=pulumi.get(__ret__, 'region'),
+        stack_type=pulumi.get(__ret__, 'stack_type'),
         status=pulumi.get(__ret__, 'status'),
+        subnet_id=pulumi.get(__ret__, 'subnet_id'),
         tags=pulumi.get(__ret__, 'tags'),
         tier=pulumi.get(__ret__, 'tier'),
-        updated=pulumi.get(__ret__, 'updated'))
+        updated=pulumi.get(__ret__, 'updated'),
+        vpc_id=pulumi.get(__ret__, 'vpc_id'))
 def get_lke_cluster_output(control_planes: Optional[pulumi.Input[Optional[Sequence[Union['GetLkeClusterControlPlaneArgs', 'GetLkeClusterControlPlaneArgsDict']]]]] = None,
                            id: Optional[pulumi.Input[_builtins.int]] = None,
                            pools: Optional[pulumi.Input[Optional[Sequence[Union['GetLkeClusterPoolArgs', 'GetLkeClusterPoolArgsDict']]]]] = None,
@@ -304,7 +343,10 @@ def get_lke_cluster_output(control_planes: Optional[pulumi.Input[Optional[Sequen
         label=pulumi.get(__response__, 'label'),
         pools=pulumi.get(__response__, 'pools'),
         region=pulumi.get(__response__, 'region'),
+        stack_type=pulumi.get(__response__, 'stack_type'),
         status=pulumi.get(__response__, 'status'),
+        subnet_id=pulumi.get(__response__, 'subnet_id'),
         tags=pulumi.get(__response__, 'tags'),
         tier=pulumi.get(__response__, 'tier'),
-        updated=pulumi.get(__response__, 'updated')))
+        updated=pulumi.get(__response__, 'updated'),
+        vpc_id=pulumi.get(__response__, 'vpc_id')))

pulumi_linode/get_node_balancer.py

@@ -28,7 +28,7 @@ class GetNodeBalancerResult:
     """
     A collection of values returned by getNodeBalancer.
     """
-    def __init__(__self__, client_conn_throttle=None, client_udp_sess_throttle=None, created=None, firewalls=None, hostname=None, id=None, ipv4=None, ipv6=None, label=None, region=None, tags=None, transfers=None, updated=None):
+    def __init__(__self__, client_conn_throttle=None, client_udp_sess_throttle=None, created=None, firewalls=None, hostname=None, id=None, ipv4=None, ipv6=None, label=None, region=None, tags=None, transfers=None, updated=None, vpcs=None):
         if client_conn_throttle and not isinstance(client_conn_throttle, int):
             raise TypeError("Expected argument 'client_conn_throttle' to be a int")
         pulumi.set(__self__, "client_conn_throttle", client_conn_throttle)
@@ -68,6 +68,9 @@ class GetNodeBalancerResult:
         if updated and not isinstance(updated, str):
             raise TypeError("Expected argument 'updated' to be a str")
         pulumi.set(__self__, "updated", updated)
+        if vpcs and not isinstance(vpcs, list):
+            raise TypeError("Expected argument 'vpcs' to be a list")
+        pulumi.set(__self__, "vpcs", vpcs)
 
     @_builtins.property
     @pulumi.getter(name="clientConnThrottle")
@@ -167,6 +170,11 @@ class GetNodeBalancerResult:
         """
         return pulumi.get(self, "updated")
 
+    @_builtins.property
+    @pulumi.getter
+    def vpcs(self) -> Sequence['outputs.GetNodeBalancerVpcResult']:
+        return pulumi.get(self, "vpcs")
+
 
 class AwaitableGetNodeBalancerResult(GetNodeBalancerResult):
     # pylint: disable=using-constant-test
@@ -186,7 +194,8 @@ class AwaitableGetNodeBalancerResult(GetNodeBalancerResult):
             region=self.region,
             tags=self.tags,
             transfers=self.transfers,
-            updated=self.updated)
+            updated=self.updated,
+            vpcs=self.vpcs)
 
 
 def get_node_balancer(firewalls: Optional[Sequence[Union['GetNodeBalancerFirewallArgs', 'GetNodeBalancerFirewallArgsDict']]] = None,
@@ -227,7 +236,8 @@ def get_node_balancer(firewalls: Optional[Sequence[Union['GetNodeBalancerFirewal
         region=pulumi.get(__ret__, 'region'),
         tags=pulumi.get(__ret__, 'tags'),
         transfers=pulumi.get(__ret__, 'transfers'),
-        updated=pulumi.get(__ret__, 'updated'))
+        updated=pulumi.get(__ret__, 'updated'),
+        vpcs=pulumi.get(__ret__, 'vpcs'))
 def get_node_balancer_output(firewalls: Optional[pulumi.Input[Optional[Sequence[Union['GetNodeBalancerFirewallArgs', 'GetNodeBalancerFirewallArgsDict']]]]] = None,
                              id: Optional[pulumi.Input[_builtins.int]] = None,
                              opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetNodeBalancerResult]:
@@ -265,4 +275,5 @@ def get_node_balancer_output(firewalls: Optional[pulumi.Input[Optional[Sequence[
         region=pulumi.get(__response__, 'region'),
         tags=pulumi.get(__response__, 'tags'),
         transfers=pulumi.get(__response__, 'transfers'),
-        updated=pulumi.get(__response__, 'updated')))
+        updated=pulumi.get(__response__, 'updated'),
+        vpcs=pulumi.get(__response__, 'vpcs')))

pulumi_linode/get_node_balancer_node.py

@@ -26,7 +26,7 @@ class GetNodeBalancerNodeResult:
     """
     A collection of values returned by getNodeBalancerNode.
     """
-    def __init__(__self__, address=None, config_id=None, id=None, label=None, mode=None, nodebalancer_id=None, status=None, weight=None):
+    def __init__(__self__, address=None, config_id=None, id=None, label=None, mode=None, nodebalancer_id=None, status=None, subnet_id=None, vpc_config_id=None, weight=None):
         if address and not isinstance(address, str):
             raise TypeError("Expected argument 'address' to be a str")
         pulumi.set(__self__, "address", address)
@@ -48,6 +48,12 @@ class GetNodeBalancerNodeResult:
         if status and not isinstance(status, str):
             raise TypeError("Expected argument 'status' to be a str")
         pulumi.set(__self__, "status", status)
+        if subnet_id and not isinstance(subnet_id, int):
+            raise TypeError("Expected argument 'subnet_id' to be a int")
+        pulumi.set(__self__, "subnet_id", subnet_id)
+        if vpc_config_id and not isinstance(vpc_config_id, int):
+            raise TypeError("Expected argument 'vpc_config_id' to be a int")
+        pulumi.set(__self__, "vpc_config_id", vpc_config_id)
         if weight and not isinstance(weight, int):
             raise TypeError("Expected argument 'weight' to be a int")
         pulumi.set(__self__, "weight", weight)
@@ -99,6 +105,22 @@ class GetNodeBalancerNodeResult:
         """
         return pulumi.get(self, "status")
 
+    @_builtins.property
+    @pulumi.getter(name="subnetId")
+    def subnet_id(self) -> _builtins.int:
+        """
+        The ID of the related VPC subnet. This is only set for VPC nodes. NOTE: VPC-attached NodeBalancers may not currently be available to all users and may require the `api_version` provider argument must be set to `v4beta`.
+        """
+        return pulumi.get(self, "subnet_id")
+
+    @_builtins.property
+    @pulumi.getter(name="vpcConfigId")
+    def vpc_config_id(self) -> _builtins.int:
+        """
+        The ID of the related NodeBalancer-VPC configuration. This is only set for VPC nodes. NOTE: VPC-attached NodeBalancers may not currently be available to all users and may require the `api_version` provider argument must be set to `v4beta`.
+        """
+        return pulumi.get(self, "vpc_config_id")
+
     @_builtins.property
     @pulumi.getter
     def weight(self) -> _builtins.int:
@@ -121,6 +143,8 @@ class AwaitableGetNodeBalancerNodeResult(GetNodeBalancerNodeResult):
             mode=self.mode,
             nodebalancer_id=self.nodebalancer_id,
             status=self.status,
+            subnet_id=self.subnet_id,
+            vpc_config_id=self.vpc_config_id,
             weight=self.weight)
 
 
@@ -163,6 +187,8 @@ def get_node_balancer_node(config_id: Optional[_builtins.int] = None,
         mode=pulumi.get(__ret__, 'mode'),
         nodebalancer_id=pulumi.get(__ret__, 'nodebalancer_id'),
         status=pulumi.get(__ret__, 'status'),
+        subnet_id=pulumi.get(__ret__, 'subnet_id'),
+        vpc_config_id=pulumi.get(__ret__, 'vpc_config_id'),
         weight=pulumi.get(__ret__, 'weight'))
 def get_node_balancer_node_output(config_id: Optional[pulumi.Input[_builtins.int]] = None,
                                   id: Optional[pulumi.Input[_builtins.int]] = None,
@@ -202,4 +228,6 @@ def get_node_balancer_node_output(config_id: Optional[pulumi.Input[_builtins.int
         mode=pulumi.get(__response__, 'mode'),
         nodebalancer_id=pulumi.get(__response__, 'nodebalancer_id'),
         status=pulumi.get(__response__, 'status'),
+        subnet_id=pulumi.get(__response__, 'subnet_id'),
+        vpc_config_id=pulumi.get(__response__, 'vpc_config_id'),
         weight=pulumi.get(__response__, 'weight')))

pulumi_linode/get_nodebalancer_vpc.py

@@ -0,0 +1,166 @@
+# coding=utf-8
+# *** WARNING: this file was generated by pulumi-language-python. ***
+# *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+import builtins as _builtins
+import warnings
+import sys
+import pulumi
+import pulumi.runtime
+from typing import Any, Mapping, Optional, Sequence, Union, overload
+if sys.version_info >= (3, 11):
+    from typing import NotRequired, TypedDict, TypeAlias
+else:
+    from typing_extensions import NotRequired, TypedDict, TypeAlias
+from . import _utilities
+
+__all__ = [
+    'GetNodebalancerVpcResult',
+    'AwaitableGetNodebalancerVpcResult',
+    'get_nodebalancer_vpc',
+    'get_nodebalancer_vpc_output',
+]
+
+@pulumi.output_type
+class GetNodebalancerVpcResult:
+    """
+    A collection of values returned by getNodebalancerVpc.
+    """
+    def __init__(__self__, id=None, ipv4_range=None, nodebalancer_id=None, subnet_id=None, vpc_id=None):
+        if id and not isinstance(id, int):
+            raise TypeError("Expected argument 'id' to be a int")
+        pulumi.set(__self__, "id", id)
+        if ipv4_range and not isinstance(ipv4_range, str):
+            raise TypeError("Expected argument 'ipv4_range' to be a str")
+        pulumi.set(__self__, "ipv4_range", ipv4_range)
+        if nodebalancer_id and not isinstance(nodebalancer_id, int):
+            raise TypeError("Expected argument 'nodebalancer_id' to be a int")
+        pulumi.set(__self__, "nodebalancer_id", nodebalancer_id)
+        if subnet_id and not isinstance(subnet_id, int):
+            raise TypeError("Expected argument 'subnet_id' to be a int")
+        pulumi.set(__self__, "subnet_id", subnet_id)
+        if vpc_id and not isinstance(vpc_id, int):
+            raise TypeError("Expected argument 'vpc_id' to be a int")
+        pulumi.set(__self__, "vpc_id", vpc_id)
+
+    @_builtins.property
+    @pulumi.getter
+    def id(self) -> _builtins.int:
+        return pulumi.get(self, "id")
+
+    @_builtins.property
+    @pulumi.getter(name="ipv4Range")
+    def ipv4_range(self) -> _builtins.str:
+        """
+        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.
+        """
+        return pulumi.get(self, "ipv4_range")
+
+    @_builtins.property
+    @pulumi.getter(name="nodebalancerId")
+    def nodebalancer_id(self) -> _builtins.int:
+        return pulumi.get(self, "nodebalancer_id")
+
+    @_builtins.property
+    @pulumi.getter(name="subnetId")
+    def subnet_id(self) -> _builtins.int:
+        """
+        The ID of this configuration's VPC subnet.
+        """
+        return pulumi.get(self, "subnet_id")
+
+    @_builtins.property
+    @pulumi.getter(name="vpcId")
+    def vpc_id(self) -> _builtins.int:
+        """
+        The ID of this configuration's VPC.
+        """
+        return pulumi.get(self, "vpc_id")
+
+
+class AwaitableGetNodebalancerVpcResult(GetNodebalancerVpcResult):
+    # pylint: disable=using-constant-test
+    def __await__(self):
+        if False:
+            yield self
+        return GetNodebalancerVpcResult(
+            id=self.id,
+            ipv4_range=self.ipv4_range,
+            nodebalancer_id=self.nodebalancer_id,
+            subnet_id=self.subnet_id,
+            vpc_id=self.vpc_id)
+
+
+def get_nodebalancer_vpc(id: Optional[_builtins.int] = None,
+                         nodebalancer_id: Optional[_builtins.int] = None,
+                         opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetNodebalancerVpcResult:
+    """
+    > **Limited Availability** VPC-attached NodeBalancers may not currently be available to all users and may require the `api_version` provider argument must be set to `v4beta`.
+
+    Provides information about a NodeBalancer VPC configuration.
+    For more information, see the corresponding [Linode APIv4 documentation](https://techdocs.akamai.com/linode-api/reference/get-node-balancer-vpc-config).
+
+    ## Example Usage
+
+    Retrieve information about a NodeBalancer VPC configuration:
+
+    ```python
+    import pulumi
+    import pulumi_linode as linode
+
+    vpc_config = linode.get_nodebalancer_vpc(nodebalancer_id=123,
+        id=456)
+    ```
+
+
+    :param _builtins.int id: The ID of the VPC configuration.
+    :param _builtins.int nodebalancer_id: The ID of the parent NodeBalancer of the VPC configuration.
+    """
+    __args__ = dict()
+    __args__['id'] = id
+    __args__['nodebalancerId'] = nodebalancer_id
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke('linode:index/getNodebalancerVpc:getNodebalancerVpc', __args__, opts=opts, typ=GetNodebalancerVpcResult).value
+
+    return AwaitableGetNodebalancerVpcResult(
+        id=pulumi.get(__ret__, 'id'),
+        ipv4_range=pulumi.get(__ret__, 'ipv4_range'),
+        nodebalancer_id=pulumi.get(__ret__, 'nodebalancer_id'),
+        subnet_id=pulumi.get(__ret__, 'subnet_id'),
+        vpc_id=pulumi.get(__ret__, 'vpc_id'))
+def get_nodebalancer_vpc_output(id: Optional[pulumi.Input[_builtins.int]] = None,
+                                nodebalancer_id: Optional[pulumi.Input[_builtins.int]] = None,
+                                opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetNodebalancerVpcResult]:
+    """
+    > **Limited Availability** VPC-attached NodeBalancers may not currently be available to all users and may require the `api_version` provider argument must be set to `v4beta`.
+
+    Provides information about a NodeBalancer VPC configuration.
+    For more information, see the corresponding [Linode APIv4 documentation](https://techdocs.akamai.com/linode-api/reference/get-node-balancer-vpc-config).
+
+    ## Example Usage
+
+    Retrieve information about a NodeBalancer VPC configuration:
+
+    ```python
+    import pulumi
+    import pulumi_linode as linode
+
+    vpc_config = linode.get_nodebalancer_vpc(nodebalancer_id=123,
+        id=456)
+    ```
+
+
+    :param _builtins.int id: The ID of the VPC configuration.
+    :param _builtins.int nodebalancer_id: The ID of the parent NodeBalancer of the VPC configuration.
+    """
+    __args__ = dict()
+    __args__['id'] = id
+    __args__['nodebalancerId'] = nodebalancer_id
+    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke_output('linode:index/getNodebalancerVpc:getNodebalancerVpc', __args__, opts=opts, typ=GetNodebalancerVpcResult)
+    return __ret__.apply(lambda __response__: GetNodebalancerVpcResult(
+        id=pulumi.get(__response__, 'id'),
+        ipv4_range=pulumi.get(__response__, 'ipv4_range'),
+        nodebalancer_id=pulumi.get(__response__, 'nodebalancer_id'),
+        subnet_id=pulumi.get(__response__, 'subnet_id'),
+        vpc_id=pulumi.get(__response__, 'vpc_id')))

pulumi_linode/get_nodebalancer_vpcs.py

@@ -0,0 +1,238 @@
+# coding=utf-8
+# *** WARNING: this file was generated by pulumi-language-python. ***
+# *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+import builtins as _builtins
+import warnings
+import sys
+import pulumi
+import pulumi.runtime
+from typing import Any, Mapping, Optional, Sequence, Union, overload
+if sys.version_info >= (3, 11):
+    from typing import NotRequired, TypedDict, TypeAlias
+else:
+    from typing_extensions import NotRequired, TypedDict, TypeAlias
+from . import _utilities
+from . import outputs
+from ._inputs import *
+
+__all__ = [
+    'GetNodebalancerVpcsResult',
+    'AwaitableGetNodebalancerVpcsResult',
+    'get_nodebalancer_vpcs',
+    'get_nodebalancer_vpcs_output',
+]
+
+@pulumi.output_type
+class GetNodebalancerVpcsResult:
+    """
+    A collection of values returned by getNodebalancerVpcs.
+    """
+    def __init__(__self__, filters=None, id=None, nodebalancer_id=None, order=None, order_by=None, vpc_configs=None):
+        if filters and not isinstance(filters, list):
+            raise TypeError("Expected argument 'filters' to be a list")
+        pulumi.set(__self__, "filters", filters)
+        if id and not isinstance(id, str):
+            raise TypeError("Expected argument 'id' to be a str")
+        pulumi.set(__self__, "id", id)
+        if nodebalancer_id and not isinstance(nodebalancer_id, int):
+            raise TypeError("Expected argument 'nodebalancer_id' to be a int")
+        pulumi.set(__self__, "nodebalancer_id", nodebalancer_id)
+        if order and not isinstance(order, str):
+            raise TypeError("Expected argument 'order' to be a str")
+        pulumi.set(__self__, "order", order)
+        if order_by and not isinstance(order_by, str):
+            raise TypeError("Expected argument 'order_by' to be a str")
+        pulumi.set(__self__, "order_by", order_by)
+        if vpc_configs and not isinstance(vpc_configs, list):
+            raise TypeError("Expected argument 'vpc_configs' to be a list")
+        pulumi.set(__self__, "vpc_configs", vpc_configs)
+
+    @_builtins.property
+    @pulumi.getter
+    def filters(self) -> Optional[Sequence['outputs.GetNodebalancerVpcsFilterResult']]:
+        return pulumi.get(self, "filters")
+
+    @_builtins.property
+    @pulumi.getter
+    def id(self) -> _builtins.str:
+        """
+        The ID of the VPC configuration.
+        """
+        return pulumi.get(self, "id")
+
+    @_builtins.property
+    @pulumi.getter(name="nodebalancerId")
+    def nodebalancer_id(self) -> _builtins.int:
+        """
+        The ID of the parent NodeBalancer for this VPC configuration.
+        """
+        return pulumi.get(self, "nodebalancer_id")
+
+    @_builtins.property
+    @pulumi.getter
+    def order(self) -> Optional[_builtins.str]:
+        return pulumi.get(self, "order")
+
+    @_builtins.property
+    @pulumi.getter(name="orderBy")
+    def order_by(self) -> Optional[_builtins.str]:
+        return pulumi.get(self, "order_by")
+
+    @_builtins.property
+    @pulumi.getter(name="vpcConfigs")
+    def vpc_configs(self) -> Sequence['outputs.GetNodebalancerVpcsVpcConfigResult']:
+        return pulumi.get(self, "vpc_configs")
+
+
+class AwaitableGetNodebalancerVpcsResult(GetNodebalancerVpcsResult):
+    # pylint: disable=using-constant-test
+    def __await__(self):
+        if False:
+            yield self
+        return GetNodebalancerVpcsResult(
+            filters=self.filters,
+            id=self.id,
+            nodebalancer_id=self.nodebalancer_id,
+            order=self.order,
+            order_by=self.order_by,
+            vpc_configs=self.vpc_configs)
+
+
+def get_nodebalancer_vpcs(filters: Optional[Sequence[Union['GetNodebalancerVpcsFilterArgs', 'GetNodebalancerVpcsFilterArgsDict']]] = None,
+                          nodebalancer_id: Optional[_builtins.int] = None,
+                          order: Optional[_builtins.str] = None,
+                          order_by: Optional[_builtins.str] = None,
+                          opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetNodebalancerVpcsResult:
+    """
+    > **Limited Availability** VPC-attached NodeBalancers may not currently be available to all users and may require the `api_version` provider argument must be set to `v4beta`.
+
+    Provides information about Linode NodeBalancers VPC configurations that match a set of filters.
+    For more information, see the [Linode APIv4 docs](https://techdocs.akamai.com/linode-api/reference/get-node-balancers).
+
+    ## Example Usage
+
+    Retrieve all VPC configurations under a NodeBalancer:
+
+    ```python
+    import pulumi
+    import pulumi_linode as linode
+
+    vpc_configs = linode.get_nodebalancer_vpcs(nodebalancer_id=12345)
+    ```
+
+    Retrieve all VPC configurations under a NodeBalancer with an IPv4 range of "10.0.0.4/30":
+
+    ```python
+    import pulumi
+    import pulumi_linode as linode
+
+    vpc_configs = linode.get_nodebalancer_vpcs(nodebalancer_id=12345,
+        filters=[{
+            "name": "ipv4_range",
+            "values": ["10.0.0.4/30"],
+        }])
+    ```
+
+    ## Filterable Fields
+
+    * `id`
+
+    * `ipv4_range`
+
+    * `nodebalancer_id`
+
+    * `subnet_id`
+
+    * `vpc_id`
+
+
+    :param _builtins.int nodebalancer_id: The ID of the NodeBalancer to list VPC configurations for.
+           
+           * `filter` - (Optional) A set of filters used to select VPC configurations that meet certain requirements.
+    :param _builtins.str order: The order in which results should be returned. (`asc`, `desc`; default `asc`)
+    :param _builtins.str order_by: The attribute to order the results by. See the Filterable Fields section for a list of valid fields.
+    """
+    __args__ = dict()
+    __args__['filters'] = filters
+    __args__['nodebalancerId'] = nodebalancer_id
+    __args__['order'] = order
+    __args__['orderBy'] = order_by
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke('linode:index/getNodebalancerVpcs:getNodebalancerVpcs', __args__, opts=opts, typ=GetNodebalancerVpcsResult).value
+
+    return AwaitableGetNodebalancerVpcsResult(
+        filters=pulumi.get(__ret__, 'filters'),
+        id=pulumi.get(__ret__, 'id'),
+        nodebalancer_id=pulumi.get(__ret__, 'nodebalancer_id'),
+        order=pulumi.get(__ret__, 'order'),
+        order_by=pulumi.get(__ret__, 'order_by'),
+        vpc_configs=pulumi.get(__ret__, 'vpc_configs'))
+def get_nodebalancer_vpcs_output(filters: Optional[pulumi.Input[Optional[Sequence[Union['GetNodebalancerVpcsFilterArgs', 'GetNodebalancerVpcsFilterArgsDict']]]]] = None,
+                                 nodebalancer_id: Optional[pulumi.Input[_builtins.int]] = None,
+                                 order: Optional[pulumi.Input[Optional[_builtins.str]]] = None,
+                                 order_by: Optional[pulumi.Input[Optional[_builtins.str]]] = None,
+                                 opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetNodebalancerVpcsResult]:
+    """
+    > **Limited Availability** VPC-attached NodeBalancers may not currently be available to all users and may require the `api_version` provider argument must be set to `v4beta`.
+
+    Provides information about Linode NodeBalancers VPC configurations that match a set of filters.
+    For more information, see the [Linode APIv4 docs](https://techdocs.akamai.com/linode-api/reference/get-node-balancers).
+
+    ## Example Usage
+
+    Retrieve all VPC configurations under a NodeBalancer:
+
+    ```python
+    import pulumi
+    import pulumi_linode as linode
+
+    vpc_configs = linode.get_nodebalancer_vpcs(nodebalancer_id=12345)
+    ```
+
+    Retrieve all VPC configurations under a NodeBalancer with an IPv4 range of "10.0.0.4/30":
+
+    ```python
+    import pulumi
+    import pulumi_linode as linode
+
+    vpc_configs = linode.get_nodebalancer_vpcs(nodebalancer_id=12345,
+        filters=[{
+            "name": "ipv4_range",
+            "values": ["10.0.0.4/30"],
+        }])
+    ```
+
+    ## Filterable Fields
+
+    * `id`
+
+    * `ipv4_range`
+
+    * `nodebalancer_id`
+
+    * `subnet_id`
+
+    * `vpc_id`
+
+
+    :param _builtins.int nodebalancer_id: The ID of the NodeBalancer to list VPC configurations for.
+           
+           * `filter` - (Optional) A set of filters used to select VPC configurations that meet certain requirements.
+    :param _builtins.str order: The order in which results should be returned. (`asc`, `desc`; default `asc`)
+    :param _builtins.str order_by: The attribute to order the results by. See the Filterable Fields section for a list of valid fields.
+    """
+    __args__ = dict()
+    __args__['filters'] = filters
+    __args__['nodebalancerId'] = nodebalancer_id
+    __args__['order'] = order
+    __args__['orderBy'] = order_by
+    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke_output('linode:index/getNodebalancerVpcs:getNodebalancerVpcs', __args__, opts=opts, typ=GetNodebalancerVpcsResult)
+    return __ret__.apply(lambda __response__: GetNodebalancerVpcsResult(
+        filters=pulumi.get(__response__, 'filters'),
+        id=pulumi.get(__response__, 'id'),
+        nodebalancer_id=pulumi.get(__response__, 'nodebalancer_id'),
+        order=pulumi.get(__response__, 'order'),
+        order_by=pulumi.get(__response__, 'order_by'),
+        vpc_configs=pulumi.get(__response__, 'vpc_configs')))