pulumiverse-scaleway 1.26.0a1742897201__py3-none-any.whl → 1.26.0a1743166124__py3-none-any.whl

pulumiverse_scaleway/get_lb_route.py

@@ -28,7 +28,7 @@ class GetLbRouteResult:
     """
     A collection of values returned by getLbRoute.
     """
-    def __init__(__self__, backend_id=None, created_at=None, frontend_id=None, id=None, match_host_header=None, match_sni=None, route_id=None, updated_at=None):
+    def __init__(__self__, backend_id=None, created_at=None, frontend_id=None, id=None, match_host_header=None, match_sni=None, match_subdomains=None, route_id=None, updated_at=None):
         if backend_id and not isinstance(backend_id, str):
             raise TypeError("Expected argument 'backend_id' to be a str")
         pulumi.set(__self__, "backend_id", backend_id)
@@ -47,6 +47,9 @@ class GetLbRouteResult:
         if match_sni and not isinstance(match_sni, str):
             raise TypeError("Expected argument 'match_sni' to be a str")
         pulumi.set(__self__, "match_sni", match_sni)
+        if match_subdomains and not isinstance(match_subdomains, bool):
+            raise TypeError("Expected argument 'match_subdomains' to be a bool")
+        pulumi.set(__self__, "match_subdomains", match_subdomains)
         if route_id and not isinstance(route_id, str):
             raise TypeError("Expected argument 'route_id' to be a str")
         pulumi.set(__self__, "route_id", route_id)
@@ -87,6 +90,11 @@ class GetLbRouteResult:
     def match_sni(self) -> str:
         return pulumi.get(self, "match_sni")
 
+    @property
+    @pulumi.getter(name="matchSubdomains")
+    def match_subdomains(self) -> bool:
+        return pulumi.get(self, "match_subdomains")
+
     @property
     @pulumi.getter(name="routeId")
     def route_id(self) -> str:
@@ -110,6 +118,7 @@ class AwaitableGetLbRouteResult(GetLbRouteResult):
             id=self.id,
             match_host_header=self.match_host_header,
             match_sni=self.match_sni,
+            match_subdomains=self.match_subdomains,
             route_id=self.route_id,
             updated_at=self.updated_at)
 
@@ -165,6 +174,7 @@ def get_lb_route(route_id: Optional[str] = None,
         id=pulumi.get(__ret__, 'id'),
         match_host_header=pulumi.get(__ret__, 'match_host_header'),
         match_sni=pulumi.get(__ret__, 'match_sni'),
+        match_subdomains=pulumi.get(__ret__, 'match_subdomains'),
         route_id=pulumi.get(__ret__, 'route_id'),
         updated_at=pulumi.get(__ret__, 'updated_at'))
 def get_lb_route_output(route_id: Optional[pulumi.Input[str]] = None,
@@ -217,5 +227,6 @@ def get_lb_route_output(route_id: Optional[pulumi.Input[str]] = None,
         id=pulumi.get(__response__, 'id'),
         match_host_header=pulumi.get(__response__, 'match_host_header'),
         match_sni=pulumi.get(__response__, 'match_sni'),
+        match_subdomains=pulumi.get(__response__, 'match_subdomains'),
         route_id=pulumi.get(__response__, 'route_id'),
         updated_at=pulumi.get(__response__, 'updated_at')))

pulumiverse_scaleway/get_secret.py

@@ -29,7 +29,7 @@ class GetSecretResult:
     """
     A collection of values returned by getSecret.
     """
-    def __init__(__self__, created_at=None, description=None, ephemeral_policies=None, id=None, name=None, organization_id=None, path=None, project_id=None, protected=None, region=None, secret_id=None, status=None, tags=None, type=None, updated_at=None, version_count=None):
+    def __init__(__self__, created_at=None, description=None, ephemeral_policies=None, id=None, name=None, organization_id=None, path=None, project_id=None, protected=None, region=None, secret_id=None, status=None, tags=None, type=None, updated_at=None, version_count=None, versions=None):
         if created_at and not isinstance(created_at, str):
             raise TypeError("Expected argument 'created_at' to be a str")
         pulumi.set(__self__, "created_at", created_at)
@@ -78,6 +78,9 @@ class GetSecretResult:
         if version_count and not isinstance(version_count, int):
             raise TypeError("Expected argument 'version_count' to be a int")
         pulumi.set(__self__, "version_count", version_count)
+        if versions and not isinstance(versions, list):
+            raise TypeError("Expected argument 'versions' to be a list")
+        pulumi.set(__self__, "versions", versions)
 
     @property
     @pulumi.getter(name="createdAt")
@@ -162,6 +165,11 @@ class GetSecretResult:
     def version_count(self) -> int:
         return pulumi.get(self, "version_count")
 
+    @property
+    @pulumi.getter
+    def versions(self) -> Sequence['outputs.GetSecretVersionResult']:
+        return pulumi.get(self, "versions")
+
 
 class AwaitableGetSecretResult(GetSecretResult):
     # pylint: disable=using-constant-test
@@ -184,7 +192,8 @@ class AwaitableGetSecretResult(GetSecretResult):
             tags=self.tags,
             type=self.type,
             updated_at=self.updated_at,
-            version_count=self.version_count)
+            version_count=self.version_count,
+            versions=self.versions)
 
 
 def get_secret(name: Optional[str] = None,
@@ -263,7 +272,8 @@ def get_secret(name: Optional[str] = None,
         tags=pulumi.get(__ret__, 'tags'),
         type=pulumi.get(__ret__, 'type'),
         updated_at=pulumi.get(__ret__, 'updated_at'),
-        version_count=pulumi.get(__ret__, 'version_count'))
+        version_count=pulumi.get(__ret__, 'version_count'),
+        versions=pulumi.get(__ret__, 'versions'))
 def get_secret_output(name: Optional[pulumi.Input[Optional[str]]] = None,
                       organization_id: Optional[pulumi.Input[Optional[str]]] = None,
                       path: Optional[pulumi.Input[Optional[str]]] = None,
@@ -339,4 +349,5 @@ def get_secret_output(name: Optional[pulumi.Input[Optional[str]]] = None,
         tags=pulumi.get(__response__, 'tags'),
         type=pulumi.get(__response__, 'type'),
         updated_at=pulumi.get(__response__, 'updated_at'),
-        version_count=pulumi.get(__response__, 'version_count')))
+        version_count=pulumi.get(__response__, 'version_count'),
+        versions=pulumi.get(__response__, 'versions')))

pulumiverse_scaleway/get_vpc_public_gateway.py

@@ -28,7 +28,13 @@ class GetVpcPublicGatewayResult:
     """
     A collection of values returned by getVpcPublicGateway.
     """
-    def __init__(__self__, bastion_enabled=None, bastion_port=None, created_at=None, enable_smtp=None, id=None, ip_id=None, name=None, organization_id=None, project_id=None, public_gateway_id=None, refresh_ssh_keys=None, status=None, tags=None, type=None, updated_at=None, upstream_dns_servers=None, zone=None):
+    def __init__(__self__, allowed_ip_ranges=None, bandwidth=None, bastion_enabled=None, bastion_port=None, created_at=None, enable_smtp=None, id=None, ip_id=None, move_to_ipam=None, name=None, organization_id=None, project_id=None, public_gateway_id=None, refresh_ssh_keys=None, status=None, tags=None, type=None, updated_at=None, upstream_dns_servers=None, zone=None):
+        if allowed_ip_ranges and not isinstance(allowed_ip_ranges, list):
+            raise TypeError("Expected argument 'allowed_ip_ranges' to be a list")
+        pulumi.set(__self__, "allowed_ip_ranges", allowed_ip_ranges)
+        if bandwidth and not isinstance(bandwidth, int):
+            raise TypeError("Expected argument 'bandwidth' to be a int")
+        pulumi.set(__self__, "bandwidth", bandwidth)
         if bastion_enabled and not isinstance(bastion_enabled, bool):
             raise TypeError("Expected argument 'bastion_enabled' to be a bool")
         pulumi.set(__self__, "bastion_enabled", bastion_enabled)
@@ -47,6 +53,9 @@ class GetVpcPublicGatewayResult:
         if ip_id and not isinstance(ip_id, str):
             raise TypeError("Expected argument 'ip_id' to be a str")
         pulumi.set(__self__, "ip_id", ip_id)
+        if move_to_ipam and not isinstance(move_to_ipam, bool):
+            raise TypeError("Expected argument 'move_to_ipam' to be a bool")
+        pulumi.set(__self__, "move_to_ipam", move_to_ipam)
         if name and not isinstance(name, str):
             raise TypeError("Expected argument 'name' to be a str")
         pulumi.set(__self__, "name", name)
@@ -81,6 +90,16 @@ class GetVpcPublicGatewayResult:
             raise TypeError("Expected argument 'zone' to be a str")
         pulumi.set(__self__, "zone", zone)
 
+    @property
+    @pulumi.getter(name="allowedIpRanges")
+    def allowed_ip_ranges(self) -> Sequence[str]:
+        return pulumi.get(self, "allowed_ip_ranges")
+
+    @property
+    @pulumi.getter
+    def bandwidth(self) -> int:
+        return pulumi.get(self, "bandwidth")
+
     @property
     @pulumi.getter(name="bastionEnabled")
     def bastion_enabled(self) -> bool:
@@ -114,6 +133,11 @@ class GetVpcPublicGatewayResult:
     def ip_id(self) -> str:
         return pulumi.get(self, "ip_id")
 
+    @property
+    @pulumi.getter(name="moveToIpam")
+    def move_to_ipam(self) -> bool:
+        return pulumi.get(self, "move_to_ipam")
+
     @property
     @pulumi.getter
     def name(self) -> Optional[str]:
@@ -176,12 +200,15 @@ class AwaitableGetVpcPublicGatewayResult(GetVpcPublicGatewayResult):
         if False:
             yield self
         return GetVpcPublicGatewayResult(
+            allowed_ip_ranges=self.allowed_ip_ranges,
+            bandwidth=self.bandwidth,
             bastion_enabled=self.bastion_enabled,
             bastion_port=self.bastion_port,
             created_at=self.created_at,
             enable_smtp=self.enable_smtp,
             id=self.id,
             ip_id=self.ip_id,
+            move_to_ipam=self.move_to_ipam,
             name=self.name,
             organization_id=self.organization_id,
             project_id=self.project_id,
@@ -234,12 +261,15 @@ def get_vpc_public_gateway(name: Optional[str] = None,
     __ret__ = pulumi.runtime.invoke('scaleway:index/getVpcPublicGateway:getVpcPublicGateway', __args__, opts=opts, typ=GetVpcPublicGatewayResult).value
 
     return AwaitableGetVpcPublicGatewayResult(
+        allowed_ip_ranges=pulumi.get(__ret__, 'allowed_ip_ranges'),
+        bandwidth=pulumi.get(__ret__, 'bandwidth'),
         bastion_enabled=pulumi.get(__ret__, 'bastion_enabled'),
         bastion_port=pulumi.get(__ret__, 'bastion_port'),
         created_at=pulumi.get(__ret__, 'created_at'),
         enable_smtp=pulumi.get(__ret__, 'enable_smtp'),
         id=pulumi.get(__ret__, 'id'),
         ip_id=pulumi.get(__ret__, 'ip_id'),
+        move_to_ipam=pulumi.get(__ret__, 'move_to_ipam'),
         name=pulumi.get(__ret__, 'name'),
         organization_id=pulumi.get(__ret__, 'organization_id'),
         project_id=pulumi.get(__ret__, 'project_id'),
@@ -289,12 +319,15 @@ def get_vpc_public_gateway_output(name: Optional[pulumi.Input[Optional[str]]] =
     opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
     __ret__ = pulumi.runtime.invoke_output('scaleway:index/getVpcPublicGateway:getVpcPublicGateway', __args__, opts=opts, typ=GetVpcPublicGatewayResult)
     return __ret__.apply(lambda __response__: GetVpcPublicGatewayResult(
+        allowed_ip_ranges=pulumi.get(__response__, 'allowed_ip_ranges'),
+        bandwidth=pulumi.get(__response__, 'bandwidth'),
         bastion_enabled=pulumi.get(__response__, 'bastion_enabled'),
         bastion_port=pulumi.get(__response__, 'bastion_port'),
         created_at=pulumi.get(__response__, 'created_at'),
         enable_smtp=pulumi.get(__response__, 'enable_smtp'),
         id=pulumi.get(__response__, 'id'),
         ip_id=pulumi.get(__response__, 'ip_id'),
+        move_to_ipam=pulumi.get(__response__, 'move_to_ipam'),
         name=pulumi.get(__response__, 'name'),
         organization_id=pulumi.get(__response__, 'organization_id'),
         project_id=pulumi.get(__response__, 'project_id'),

pulumiverse_scaleway/get_vpc_public_gateway_dhcp.py

@@ -225,6 +225,10 @@ class AwaitableGetVpcPublicGatewayDhcpResult(GetVpcPublicGatewayDhcpResult):
 def get_vpc_public_gateway_dhcp(dhcp_id: Optional[str] = None,
                                 opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetVpcPublicGatewayDhcpResult:
     """
+    > **Important:**  The data source `network.PublicGatewayDhcp` has been deprecated and will no longer be supported.
+    In 2023, DHCP functionality was moved from Public Gateways to Private Networks, DHCP resources are now no longer needed.
+    For more information, please refer to the dedicated guide.
+
     Gets information about a Public Gateway DHCP configuration.
 
     ## Example Usage
@@ -268,6 +272,10 @@ def get_vpc_public_gateway_dhcp(dhcp_id: Optional[str] = None,
 def get_vpc_public_gateway_dhcp_output(dhcp_id: Optional[pulumi.Input[str]] = None,
                                        opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetVpcPublicGatewayDhcpResult]:
     """
+    > **Important:**  The data source `network.PublicGatewayDhcp` has been deprecated and will no longer be supported.
+    In 2023, DHCP functionality was moved from Public Gateways to Private Networks, DHCP resources are now no longer needed.
+    For more information, please refer to the dedicated guide.
+
     Gets information about a Public Gateway DHCP configuration.
 
     ## Example Usage

pulumiverse_scaleway/get_vpc_public_gateway_dhcp_reservation.py

@@ -148,6 +148,10 @@ def get_vpc_public_gateway_dhcp_reservation(gateway_network_id: Optional[str] =
                                             zone: Optional[str] = None,
                                             opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetVpcPublicGatewayDhcpReservationResult:
     """
+    > **Important:**  The data source `network.PublicGatewayDhcpReservation` has been deprecated and will no longer be supported.
+    In 2023, DHCP functionality was moved from Public Gateways to Private Networks, DHCP resources are now no longer needed.
+    You can use IPAM to manage your IPs. For more information, please refer to the dedicated guide.
+
     Gets information about a DHCP entry. For further information, please see the
     [API documentation](https://www.scaleway.com/en/developers/api/public-gateway/#path-dhcp-entries-list-dhcp-entries).
 
@@ -270,6 +274,10 @@ def get_vpc_public_gateway_dhcp_reservation_output(gateway_network_id: Optional[
                                                    zone: Optional[pulumi.Input[Optional[str]]] = None,
                                                    opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetVpcPublicGatewayDhcpReservationResult]:
     """
+    > **Important:**  The data source `network.PublicGatewayDhcpReservation` has been deprecated and will no longer be supported.
+    In 2023, DHCP functionality was moved from Public Gateways to Private Networks, DHCP resources are now no longer needed.
+    You can use IPAM to manage your IPs. For more information, please refer to the dedicated guide.
+
     Gets information about a DHCP entry. For further information, please see the
     [API documentation](https://www.scaleway.com/en/developers/api/public-gateway/#path-dhcp-entries-list-dhcp-entries).
 

pulumiverse_scaleway/loadbalancer_backend.py

@@ -1056,7 +1056,7 @@ class LoadbalancerBackend(pulumi.CustomResource):
             forward_protocol="http",
             forward_port=80,
             health_check_http={
-                "uri": "www.test.com/health",
+                "uri": "/health",
             })
         ```
 
@@ -1140,7 +1140,7 @@ class LoadbalancerBackend(pulumi.CustomResource):
             forward_protocol="http",
             forward_port=80,
             health_check_http={
-                "uri": "www.test.com/health",
+                "uri": "/health",
             })
         ```
 

pulumiverse_scaleway/loadbalancer_frontend.py

@@ -26,6 +26,7 @@ class LoadbalancerFrontendArgs:
                  lb_id: pulumi.Input[str],
                  acls: Optional[pulumi.Input[Sequence[pulumi.Input['LoadbalancerFrontendAclArgs']]]] = None,
                  certificate_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
+                 connection_rate_limit: Optional[pulumi.Input[int]] = None,
                  enable_http3: Optional[pulumi.Input[bool]] = None,
                  external_acls: Optional[pulumi.Input[bool]] = None,
                  name: Optional[pulumi.Input[str]] = None,
@@ -41,6 +42,7 @@ class LoadbalancerFrontendArgs:
         :param pulumi.Input[Sequence[pulumi.Input[str]]] certificate_ids: List of certificate IDs that should be used by the frontend.
                
                > **Important:** Certificates are not allowed on port 80.
+        :param pulumi.Input[int] connection_rate_limit: The rate limit for new connections established on this frontend. Use 0 value to disable, else value is connections per second.
         :param pulumi.Input[bool] enable_http3: Activates HTTP/3 protocol.
         :param pulumi.Input[bool] external_acls: A boolean to specify whether to use lb_acl.
                If `external_acls` is set to `true`, `acl` can not be set directly in the Load Balancer frontend.
@@ -54,6 +56,8 @@ class LoadbalancerFrontendArgs:
             pulumi.set(__self__, "acls", acls)
         if certificate_ids is not None:
             pulumi.set(__self__, "certificate_ids", certificate_ids)
+        if connection_rate_limit is not None:
+            pulumi.set(__self__, "connection_rate_limit", connection_rate_limit)
         if enable_http3 is not None:
             pulumi.set(__self__, "enable_http3", enable_http3)
         if external_acls is not None:
@@ -127,6 +131,18 @@ class LoadbalancerFrontendArgs:
     def certificate_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
         pulumi.set(self, "certificate_ids", value)
 
+    @property
+    @pulumi.getter(name="connectionRateLimit")
+    def connection_rate_limit(self) -> Optional[pulumi.Input[int]]:
+        """
+        The rate limit for new connections established on this frontend. Use 0 value to disable, else value is connections per second.
+        """
+        return pulumi.get(self, "connection_rate_limit")
+
+    @connection_rate_limit.setter
+    def connection_rate_limit(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "connection_rate_limit", value)
+
     @property
     @pulumi.getter(name="enableHttp3")
     def enable_http3(self) -> Optional[pulumi.Input[bool]]:
@@ -184,6 +200,7 @@ class _LoadbalancerFrontendState:
                  backend_id: Optional[pulumi.Input[str]] = None,
                  certificate_id: Optional[pulumi.Input[str]] = None,
                  certificate_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
+                 connection_rate_limit: Optional[pulumi.Input[int]] = None,
                  enable_http3: Optional[pulumi.Input[bool]] = None,
                  external_acls: Optional[pulumi.Input[bool]] = None,
                  inbound_port: Optional[pulumi.Input[int]] = None,
@@ -200,6 +217,7 @@ class _LoadbalancerFrontendState:
         :param pulumi.Input[Sequence[pulumi.Input[str]]] certificate_ids: List of certificate IDs that should be used by the frontend.
                
                > **Important:** Certificates are not allowed on port 80.
+        :param pulumi.Input[int] connection_rate_limit: The rate limit for new connections established on this frontend. Use 0 value to disable, else value is connections per second.
         :param pulumi.Input[bool] enable_http3: Activates HTTP/3 protocol.
         :param pulumi.Input[bool] external_acls: A boolean to specify whether to use lb_acl.
                If `external_acls` is set to `true`, `acl` can not be set directly in the Load Balancer frontend.
@@ -219,6 +237,8 @@ class _LoadbalancerFrontendState:
             pulumi.set(__self__, "certificate_id", certificate_id)
         if certificate_ids is not None:
             pulumi.set(__self__, "certificate_ids", certificate_ids)
+        if connection_rate_limit is not None:
+            pulumi.set(__self__, "connection_rate_limit", connection_rate_limit)
         if enable_http3 is not None:
             pulumi.set(__self__, "enable_http3", enable_http3)
         if external_acls is not None:
@@ -285,6 +305,18 @@ class _LoadbalancerFrontendState:
     def certificate_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
         pulumi.set(self, "certificate_ids", value)
 
+    @property
+    @pulumi.getter(name="connectionRateLimit")
+    def connection_rate_limit(self) -> Optional[pulumi.Input[int]]:
+        """
+        The rate limit for new connections established on this frontend. Use 0 value to disable, else value is connections per second.
+        """
+        return pulumi.get(self, "connection_rate_limit")
+
+    @connection_rate_limit.setter
+    def connection_rate_limit(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "connection_rate_limit", value)
+
     @property
     @pulumi.getter(name="enableHttp3")
     def enable_http3(self) -> Optional[pulumi.Input[bool]]:
@@ -372,6 +404,7 @@ class LoadbalancerFrontend(pulumi.CustomResource):
                  acls: Optional[pulumi.Input[Sequence[pulumi.Input[Union['LoadbalancerFrontendAclArgs', 'LoadbalancerFrontendAclArgsDict']]]]] = None,
                  backend_id: Optional[pulumi.Input[str]] = None,
                  certificate_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
+                 connection_rate_limit: Optional[pulumi.Input[int]] = None,
                  enable_http3: Optional[pulumi.Input[bool]] = None,
                  external_acls: Optional[pulumi.Input[bool]] = None,
                  inbound_port: Optional[pulumi.Input[int]] = None,
@@ -506,6 +539,7 @@ class LoadbalancerFrontend(pulumi.CustomResource):
         :param pulumi.Input[Sequence[pulumi.Input[str]]] certificate_ids: List of certificate IDs that should be used by the frontend.
                
                > **Important:** Certificates are not allowed on port 80.
+        :param pulumi.Input[int] connection_rate_limit: The rate limit for new connections established on this frontend. Use 0 value to disable, else value is connections per second.
         :param pulumi.Input[bool] enable_http3: Activates HTTP/3 protocol.
         :param pulumi.Input[bool] external_acls: A boolean to specify whether to use lb_acl.
                If `external_acls` is set to `true`, `acl` can not be set directly in the Load Balancer frontend.
@@ -656,6 +690,7 @@ class LoadbalancerFrontend(pulumi.CustomResource):
                  acls: Optional[pulumi.Input[Sequence[pulumi.Input[Union['LoadbalancerFrontendAclArgs', 'LoadbalancerFrontendAclArgsDict']]]]] = None,
                  backend_id: Optional[pulumi.Input[str]] = None,
                  certificate_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
+                 connection_rate_limit: Optional[pulumi.Input[int]] = None,
                  enable_http3: Optional[pulumi.Input[bool]] = None,
                  external_acls: Optional[pulumi.Input[bool]] = None,
                  inbound_port: Optional[pulumi.Input[int]] = None,
@@ -677,6 +712,7 @@ class LoadbalancerFrontend(pulumi.CustomResource):
                 raise TypeError("Missing required property 'backend_id'")
             __props__.__dict__["backend_id"] = backend_id
             __props__.__dict__["certificate_ids"] = certificate_ids
+            __props__.__dict__["connection_rate_limit"] = connection_rate_limit
             __props__.__dict__["enable_http3"] = enable_http3
             __props__.__dict__["external_acls"] = external_acls
             if inbound_port is None and not opts.urn:
@@ -702,6 +738,7 @@ class LoadbalancerFrontend(pulumi.CustomResource):
             backend_id: Optional[pulumi.Input[str]] = None,
             certificate_id: Optional[pulumi.Input[str]] = None,
             certificate_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
+            connection_rate_limit: Optional[pulumi.Input[int]] = None,
             enable_http3: Optional[pulumi.Input[bool]] = None,
             external_acls: Optional[pulumi.Input[bool]] = None,
             inbound_port: Optional[pulumi.Input[int]] = None,
@@ -723,6 +760,7 @@ class LoadbalancerFrontend(pulumi.CustomResource):
         :param pulumi.Input[Sequence[pulumi.Input[str]]] certificate_ids: List of certificate IDs that should be used by the frontend.
                
                > **Important:** Certificates are not allowed on port 80.
+        :param pulumi.Input[int] connection_rate_limit: The rate limit for new connections established on this frontend. Use 0 value to disable, else value is connections per second.
         :param pulumi.Input[bool] enable_http3: Activates HTTP/3 protocol.
         :param pulumi.Input[bool] external_acls: A boolean to specify whether to use lb_acl.
                If `external_acls` is set to `true`, `acl` can not be set directly in the Load Balancer frontend.
@@ -739,6 +777,7 @@ class LoadbalancerFrontend(pulumi.CustomResource):
         __props__.__dict__["backend_id"] = backend_id
         __props__.__dict__["certificate_id"] = certificate_id
         __props__.__dict__["certificate_ids"] = certificate_ids
+        __props__.__dict__["connection_rate_limit"] = connection_rate_limit
         __props__.__dict__["enable_http3"] = enable_http3
         __props__.__dict__["external_acls"] = external_acls
         __props__.__dict__["inbound_port"] = inbound_port
@@ -784,6 +823,14 @@ class LoadbalancerFrontend(pulumi.CustomResource):
         """
         return pulumi.get(self, "certificate_ids")
 
+    @property
+    @pulumi.getter(name="connectionRateLimit")
+    def connection_rate_limit(self) -> pulumi.Output[Optional[int]]:
+        """
+        The rate limit for new connections established on this frontend. Use 0 value to disable, else value is connections per second.
+        """
+        return pulumi.get(self, "connection_rate_limit")
+
     @property
     @pulumi.getter(name="enableHttp3")
     def enable_http3(self) -> pulumi.Output[Optional[bool]]:

pulumiverse_scaleway/loadbalancer_route.py

@@ -22,7 +22,8 @@ class LoadbalancerRouteArgs:
                  backend_id: pulumi.Input[str],
                  frontend_id: pulumi.Input[str],
                  match_host_header: Optional[pulumi.Input[str]] = None,
-                 match_sni: Optional[pulumi.Input[str]] = None):
+                 match_sni: Optional[pulumi.Input[str]] = None,
+                 match_subdomains: Optional[pulumi.Input[bool]] = None):
         """
         The set of arguments for constructing a LoadbalancerRoute resource.
         :param pulumi.Input[str] backend_id: The ID of the backend the route is associated with.
@@ -35,6 +36,7 @@ class LoadbalancerRouteArgs:
                Only one of `match_sni` and `match_host_header` should be specified.
                
                > **Important:** This field should be set for routes on TCP Load Balancers.
+        :param pulumi.Input[bool] match_subdomains: If true, all subdomains will match.
         """
         pulumi.set(__self__, "backend_id", backend_id)
         pulumi.set(__self__, "frontend_id", frontend_id)
@@ -42,6 +44,8 @@ class LoadbalancerRouteArgs:
             pulumi.set(__self__, "match_host_header", match_host_header)
         if match_sni is not None:
             pulumi.set(__self__, "match_sni", match_sni)
+        if match_subdomains is not None:
+            pulumi.set(__self__, "match_subdomains", match_subdomains)
 
     @property
     @pulumi.getter(name="backendId")
@@ -97,6 +101,18 @@ class LoadbalancerRouteArgs:
     def match_sni(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "match_sni", value)
 
+    @property
+    @pulumi.getter(name="matchSubdomains")
+    def match_subdomains(self) -> Optional[pulumi.Input[bool]]:
+        """
+        If true, all subdomains will match.
+        """
+        return pulumi.get(self, "match_subdomains")
+
+    @match_subdomains.setter
+    def match_subdomains(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "match_subdomains", value)
+
 
 @pulumi.input_type
 class _LoadbalancerRouteState:
@@ -106,6 +122,7 @@ class _LoadbalancerRouteState:
                  frontend_id: Optional[pulumi.Input[str]] = None,
                  match_host_header: Optional[pulumi.Input[str]] = None,
                  match_sni: Optional[pulumi.Input[str]] = None,
+                 match_subdomains: Optional[pulumi.Input[bool]] = None,
                  updated_at: Optional[pulumi.Input[str]] = None):
         """
         Input properties used for looking up and filtering LoadbalancerRoute resources.
@@ -120,6 +137,7 @@ class _LoadbalancerRouteState:
                Only one of `match_sni` and `match_host_header` should be specified.
                
                > **Important:** This field should be set for routes on TCP Load Balancers.
+        :param pulumi.Input[bool] match_subdomains: If true, all subdomains will match.
         :param pulumi.Input[str] updated_at: The date on which the route was last updated.
         """
         if backend_id is not None:
@@ -132,6 +150,8 @@ class _LoadbalancerRouteState:
             pulumi.set(__self__, "match_host_header", match_host_header)
         if match_sni is not None:
             pulumi.set(__self__, "match_sni", match_sni)
+        if match_subdomains is not None:
+            pulumi.set(__self__, "match_subdomains", match_subdomains)
         if updated_at is not None:
             pulumi.set(__self__, "updated_at", updated_at)
 
@@ -201,6 +221,18 @@ class _LoadbalancerRouteState:
     def match_sni(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "match_sni", value)
 
+    @property
+    @pulumi.getter(name="matchSubdomains")
+    def match_subdomains(self) -> Optional[pulumi.Input[bool]]:
+        """
+        If true, all subdomains will match.
+        """
+        return pulumi.get(self, "match_subdomains")
+
+    @match_subdomains.setter
+    def match_subdomains(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "match_subdomains", value)
+
     @property
     @pulumi.getter(name="updatedAt")
     def updated_at(self) -> Optional[pulumi.Input[str]]:
@@ -228,6 +260,7 @@ class LoadbalancerRoute(pulumi.CustomResource):
                  frontend_id: Optional[pulumi.Input[str]] = None,
                  match_host_header: Optional[pulumi.Input[str]] = None,
                  match_sni: Optional[pulumi.Input[str]] = None,
+                 match_subdomains: Optional[pulumi.Input[bool]] = None,
                  __props__=None):
         """
         Creates and manages Scaleway Load Balancer routes.
@@ -310,6 +343,7 @@ class LoadbalancerRoute(pulumi.CustomResource):
                Only one of `match_sni` and `match_host_header` should be specified.
                
                > **Important:** This field should be set for routes on TCP Load Balancers.
+        :param pulumi.Input[bool] match_subdomains: If true, all subdomains will match.
         """
         ...
     @overload
@@ -405,6 +439,7 @@ class LoadbalancerRoute(pulumi.CustomResource):
                  frontend_id: Optional[pulumi.Input[str]] = None,
                  match_host_header: Optional[pulumi.Input[str]] = None,
                  match_sni: Optional[pulumi.Input[str]] = None,
+                 match_subdomains: Optional[pulumi.Input[bool]] = None,
                  __props__=None):
         pulumi.log.warn("""LoadbalancerRoute is deprecated: scaleway.index/loadbalancerroute.LoadbalancerRoute has been deprecated in favor of scaleway.loadbalancers/route.Route""")
         opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
@@ -423,6 +458,7 @@ class LoadbalancerRoute(pulumi.CustomResource):
             __props__.__dict__["frontend_id"] = frontend_id
             __props__.__dict__["match_host_header"] = match_host_header
             __props__.__dict__["match_sni"] = match_sni
+            __props__.__dict__["match_subdomains"] = match_subdomains
             __props__.__dict__["created_at"] = None
             __props__.__dict__["updated_at"] = None
         super(LoadbalancerRoute, __self__).__init__(
@@ -440,6 +476,7 @@ class LoadbalancerRoute(pulumi.CustomResource):
             frontend_id: Optional[pulumi.Input[str]] = None,
             match_host_header: Optional[pulumi.Input[str]] = None,
             match_sni: Optional[pulumi.Input[str]] = None,
+            match_subdomains: Optional[pulumi.Input[bool]] = None,
             updated_at: Optional[pulumi.Input[str]] = None) -> 'LoadbalancerRoute':
         """
         Get an existing LoadbalancerRoute resource's state with the given name, id, and optional extra
@@ -459,6 +496,7 @@ class LoadbalancerRoute(pulumi.CustomResource):
                Only one of `match_sni` and `match_host_header` should be specified.
                
                > **Important:** This field should be set for routes on TCP Load Balancers.
+        :param pulumi.Input[bool] match_subdomains: If true, all subdomains will match.
         :param pulumi.Input[str] updated_at: The date on which the route was last updated.
         """
         opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
@@ -470,6 +508,7 @@ class LoadbalancerRoute(pulumi.CustomResource):
         __props__.__dict__["frontend_id"] = frontend_id
         __props__.__dict__["match_host_header"] = match_host_header
         __props__.__dict__["match_sni"] = match_sni
+        __props__.__dict__["match_subdomains"] = match_subdomains
         __props__.__dict__["updated_at"] = updated_at
         return LoadbalancerRoute(resource_name, opts=opts, __props__=__props__)
 
@@ -519,6 +558,14 @@ class LoadbalancerRoute(pulumi.CustomResource):
         """
         return pulumi.get(self, "match_sni")
 
+    @property
+    @pulumi.getter(name="matchSubdomains")
+    def match_subdomains(self) -> pulumi.Output[Optional[bool]]:
+        """
+        If true, all subdomains will match.
+        """
+        return pulumi.get(self, "match_subdomains")
+
     @property
     @pulumi.getter(name="updatedAt")
     def updated_at(self) -> pulumi.Output[str]:

pulumiverse_scaleway/loadbalancers/backend.py

@@ -1051,7 +1051,7 @@ class Backend(pulumi.CustomResource):
             forward_protocol="http",
             forward_port=80,
             health_check_http={
-                "uri": "www.test.com/health",
+                "uri": "/health",
             })
         ```
 
@@ -1135,7 +1135,7 @@ class Backend(pulumi.CustomResource):
             forward_protocol="http",
             forward_port=80,
             health_check_http={
-                "uri": "www.test.com/health",
+                "uri": "/health",
             })
         ```