pulumi-gcp 8.9.0a1731366299__py3-none-any.whl → 8.9.0a1731480835__py3-none-any.whl

pulumi_gcp/compute/region_security_policy.py

@@ -26,6 +26,7 @@ class RegionSecurityPolicyArgs:
                  name: Optional[pulumi.Input[str]] = None,
                  project: Optional[pulumi.Input[str]] = None,
                  region: Optional[pulumi.Input[str]] = None,
+                 rules: Optional[pulumi.Input[Sequence[pulumi.Input['RegionSecurityPolicyRuleArgs']]]] = None,
                  type: Optional[pulumi.Input[str]] = None,
                  user_defined_fields: Optional[pulumi.Input[Sequence[pulumi.Input['RegionSecurityPolicyUserDefinedFieldArgs']]]] = None):
         """
@@ -42,6 +43,8 @@ class RegionSecurityPolicyArgs:
                If it is not provided, the provider project is used.
         :param pulumi.Input[str] region: The Region in which the created Region Security Policy should reside.
                If it is not provided, the provider region is used.
+        :param pulumi.Input[Sequence[pulumi.Input['RegionSecurityPolicyRuleArgs']]] rules: The set of rules that belong to this policy. There must always be a default rule (rule with priority 2147483647 and match "*"). If no rules are provided when creating a security policy, a default rule with action "allow" will be added.
+               Structure is documented below.
         :param pulumi.Input[str] type: The type indicates the intended use of the security policy.
                - CLOUD_ARMOR: Cloud Armor backend security policies can be configured to filter incoming HTTP requests targeting backend services. They filter requests before they hit the origin servers.
                - CLOUD_ARMOR_EDGE: Cloud Armor edge security policies can be configured to filter incoming HTTP requests targeting backend services (including Cloud CDN-enabled) as well as backend buckets (Cloud Storage). They filter requests before the request is served from Google's cache.
@@ -63,6 +66,8 @@ class RegionSecurityPolicyArgs:
             pulumi.set(__self__, "project", project)
         if region is not None:
             pulumi.set(__self__, "region", region)
+        if rules is not None:
+            pulumi.set(__self__, "rules", rules)
         if type is not None:
             pulumi.set(__self__, "type", type)
         if user_defined_fields is not None:
@@ -135,6 +140,19 @@ class RegionSecurityPolicyArgs:
     def region(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "region", value)
 
+    @property
+    @pulumi.getter
+    def rules(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RegionSecurityPolicyRuleArgs']]]]:
+        """
+        The set of rules that belong to this policy. There must always be a default rule (rule with priority 2147483647 and match "*"). If no rules are provided when creating a security policy, a default rule with action "allow" will be added.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "rules")
+
+    @rules.setter
+    def rules(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['RegionSecurityPolicyRuleArgs']]]]):
+        pulumi.set(self, "rules", value)
+
     @property
     @pulumi.getter
     def type(self) -> Optional[pulumi.Input[str]]:
@@ -178,6 +196,7 @@ class _RegionSecurityPolicyState:
                  policy_id: Optional[pulumi.Input[str]] = None,
                  project: Optional[pulumi.Input[str]] = None,
                  region: Optional[pulumi.Input[str]] = None,
+                 rules: Optional[pulumi.Input[Sequence[pulumi.Input['RegionSecurityPolicyRuleArgs']]]] = None,
                  self_link: Optional[pulumi.Input[str]] = None,
                  self_link_with_policy_id: Optional[pulumi.Input[str]] = None,
                  type: Optional[pulumi.Input[str]] = None,
@@ -199,6 +218,8 @@ class _RegionSecurityPolicyState:
                If it is not provided, the provider project is used.
         :param pulumi.Input[str] region: The Region in which the created Region Security Policy should reside.
                If it is not provided, the provider region is used.
+        :param pulumi.Input[Sequence[pulumi.Input['RegionSecurityPolicyRuleArgs']]] rules: The set of rules that belong to this policy. There must always be a default rule (rule with priority 2147483647 and match "*"). If no rules are provided when creating a security policy, a default rule with action "allow" will be added.
+               Structure is documented below.
         :param pulumi.Input[str] self_link: Server-defined URL for the resource.
         :param pulumi.Input[str] self_link_with_policy_id: Server-defined URL for this resource with the resource id.
         :param pulumi.Input[str] type: The type indicates the intended use of the security policy.
@@ -226,6 +247,8 @@ class _RegionSecurityPolicyState:
             pulumi.set(__self__, "project", project)
         if region is not None:
             pulumi.set(__self__, "region", region)
+        if rules is not None:
+            pulumi.set(__self__, "rules", rules)
         if self_link is not None:
             pulumi.set(__self__, "self_link", self_link)
         if self_link_with_policy_id is not None:
@@ -327,6 +350,19 @@ class _RegionSecurityPolicyState:
     def region(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "region", value)
 
+    @property
+    @pulumi.getter
+    def rules(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RegionSecurityPolicyRuleArgs']]]]:
+        """
+        The set of rules that belong to this policy. There must always be a default rule (rule with priority 2147483647 and match "*"). If no rules are provided when creating a security policy, a default rule with action "allow" will be added.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "rules")
+
+    @rules.setter
+    def rules(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['RegionSecurityPolicyRuleArgs']]]]):
+        pulumi.set(self, "rules", value)
+
     @property
     @pulumi.getter(name="selfLink")
     def self_link(self) -> Optional[pulumi.Input[str]]:
@@ -394,6 +430,7 @@ class RegionSecurityPolicy(pulumi.CustomResource):
                  name: Optional[pulumi.Input[str]] = None,
                  project: Optional[pulumi.Input[str]] = None,
                  region: Optional[pulumi.Input[str]] = None,
+                 rules: Optional[pulumi.Input[Sequence[pulumi.Input[Union['RegionSecurityPolicyRuleArgs', 'RegionSecurityPolicyRuleArgsDict']]]]] = None,
                  type: Optional[pulumi.Input[str]] = None,
                  user_defined_fields: Optional[pulumi.Input[Sequence[pulumi.Input[Union['RegionSecurityPolicyUserDefinedFieldArgs', 'RegionSecurityPolicyUserDefinedFieldArgsDict']]]]] = None,
                  __props__=None):
@@ -452,6 +489,39 @@ class RegionSecurityPolicy(pulumi.CustomResource):
                 },
             ])
         ```
+        ### Region Security Policy With Rules
+
+        ```python
+        import pulumi
+        import pulumi_gcp as gcp
+
+        region_sec_policy_with_rules = gcp.compute.RegionSecurityPolicy("region-sec-policy-with-rules",
+            name="my-sec-policy-with-rules",
+            description="basic region security policy with multiple rules",
+            type="CLOUD_ARMOR",
+            rules=[
+                {
+                    "action": "deny",
+                    "priority": 1000,
+                    "match": {
+                        "expr": {
+                            "expression": "request.path.matches(\\"/login.html\\") && token.recaptcha_session.score < 0.2",
+                        },
+                    },
+                },
+                {
+                    "action": "deny",
+                    "priority": 2147483647,
+                    "match": {
+                        "versioned_expr": "SRC_IPS_V1",
+                        "config": {
+                            "src_ip_ranges": ["*"],
+                        },
+                    },
+                    "description": "default rule",
+                },
+            ])
+        ```
 
         ## Import
 
@@ -497,6 +567,8 @@ class RegionSecurityPolicy(pulumi.CustomResource):
                If it is not provided, the provider project is used.
         :param pulumi.Input[str] region: The Region in which the created Region Security Policy should reside.
                If it is not provided, the provider region is used.
+        :param pulumi.Input[Sequence[pulumi.Input[Union['RegionSecurityPolicyRuleArgs', 'RegionSecurityPolicyRuleArgsDict']]]] rules: The set of rules that belong to this policy. There must always be a default rule (rule with priority 2147483647 and match "*"). If no rules are provided when creating a security policy, a default rule with action "allow" will be added.
+               Structure is documented below.
         :param pulumi.Input[str] type: The type indicates the intended use of the security policy.
                - CLOUD_ARMOR: Cloud Armor backend security policies can be configured to filter incoming HTTP requests targeting backend services. They filter requests before they hit the origin servers.
                - CLOUD_ARMOR_EDGE: Cloud Armor edge security policies can be configured to filter incoming HTTP requests targeting backend services (including Cloud CDN-enabled) as well as backend buckets (Cloud Storage). They filter requests before the request is served from Google's cache.
@@ -569,6 +641,39 @@ class RegionSecurityPolicy(pulumi.CustomResource):
                 },
             ])
         ```
+        ### Region Security Policy With Rules
+
+        ```python
+        import pulumi
+        import pulumi_gcp as gcp
+
+        region_sec_policy_with_rules = gcp.compute.RegionSecurityPolicy("region-sec-policy-with-rules",
+            name="my-sec-policy-with-rules",
+            description="basic region security policy with multiple rules",
+            type="CLOUD_ARMOR",
+            rules=[
+                {
+                    "action": "deny",
+                    "priority": 1000,
+                    "match": {
+                        "expr": {
+                            "expression": "request.path.matches(\\"/login.html\\") && token.recaptcha_session.score < 0.2",
+                        },
+                    },
+                },
+                {
+                    "action": "deny",
+                    "priority": 2147483647,
+                    "match": {
+                        "versioned_expr": "SRC_IPS_V1",
+                        "config": {
+                            "src_ip_ranges": ["*"],
+                        },
+                    },
+                    "description": "default rule",
+                },
+            ])
+        ```
 
         ## Import
 
@@ -620,6 +725,7 @@ class RegionSecurityPolicy(pulumi.CustomResource):
                  name: Optional[pulumi.Input[str]] = None,
                  project: Optional[pulumi.Input[str]] = None,
                  region: Optional[pulumi.Input[str]] = None,
+                 rules: Optional[pulumi.Input[Sequence[pulumi.Input[Union['RegionSecurityPolicyRuleArgs', 'RegionSecurityPolicyRuleArgsDict']]]]] = None,
                  type: Optional[pulumi.Input[str]] = None,
                  user_defined_fields: Optional[pulumi.Input[Sequence[pulumi.Input[Union['RegionSecurityPolicyUserDefinedFieldArgs', 'RegionSecurityPolicyUserDefinedFieldArgsDict']]]]] = None,
                  __props__=None):
@@ -636,6 +742,7 @@ class RegionSecurityPolicy(pulumi.CustomResource):
             __props__.__dict__["name"] = name
             __props__.__dict__["project"] = project
             __props__.__dict__["region"] = region
+            __props__.__dict__["rules"] = rules
             __props__.__dict__["type"] = type
             __props__.__dict__["user_defined_fields"] = user_defined_fields
             __props__.__dict__["fingerprint"] = None
@@ -659,6 +766,7 @@ class RegionSecurityPolicy(pulumi.CustomResource):
             policy_id: Optional[pulumi.Input[str]] = None,
             project: Optional[pulumi.Input[str]] = None,
             region: Optional[pulumi.Input[str]] = None,
+            rules: Optional[pulumi.Input[Sequence[pulumi.Input[Union['RegionSecurityPolicyRuleArgs', 'RegionSecurityPolicyRuleArgsDict']]]]] = None,
             self_link: Optional[pulumi.Input[str]] = None,
             self_link_with_policy_id: Optional[pulumi.Input[str]] = None,
             type: Optional[pulumi.Input[str]] = None,
@@ -685,6 +793,8 @@ class RegionSecurityPolicy(pulumi.CustomResource):
                If it is not provided, the provider project is used.
         :param pulumi.Input[str] region: The Region in which the created Region Security Policy should reside.
                If it is not provided, the provider region is used.
+        :param pulumi.Input[Sequence[pulumi.Input[Union['RegionSecurityPolicyRuleArgs', 'RegionSecurityPolicyRuleArgsDict']]]] rules: The set of rules that belong to this policy. There must always be a default rule (rule with priority 2147483647 and match "*"). If no rules are provided when creating a security policy, a default rule with action "allow" will be added.
+               Structure is documented below.
         :param pulumi.Input[str] self_link: Server-defined URL for the resource.
         :param pulumi.Input[str] self_link_with_policy_id: Server-defined URL for this resource with the resource id.
         :param pulumi.Input[str] type: The type indicates the intended use of the security policy.
@@ -709,6 +819,7 @@ class RegionSecurityPolicy(pulumi.CustomResource):
         __props__.__dict__["policy_id"] = policy_id
         __props__.__dict__["project"] = project
         __props__.__dict__["region"] = region
+        __props__.__dict__["rules"] = rules
         __props__.__dict__["self_link"] = self_link
         __props__.__dict__["self_link_with_policy_id"] = self_link_with_policy_id
         __props__.__dict__["type"] = type
@@ -779,6 +890,15 @@ class RegionSecurityPolicy(pulumi.CustomResource):
         """
         return pulumi.get(self, "region")
 
+    @property
+    @pulumi.getter
+    def rules(self) -> pulumi.Output[Sequence['outputs.RegionSecurityPolicyRule']]:
+        """
+        The set of rules that belong to this policy. There must always be a default rule (rule with priority 2147483647 and match "*"). If no rules are provided when creating a security policy, a default rule with action "allow" will be added.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "rules")
+
     @property
     @pulumi.getter(name="selfLink")
     def self_link(self) -> pulumi.Output[str]:

pulumi_gcp/compute/region_security_policy_rule.py

@@ -16,10 +16,10 @@ from .. import _utilities
 from . import outputs
 from ._inputs import *
 
-__all__ = ['RegionSecurityPolicyRuleArgs', 'RegionSecurityPolicyRule']
+__all__ = ['RegionSecurityPolicyRuleInitArgs', 'RegionSecurityPolicyRule']
 
 @pulumi.input_type
-class RegionSecurityPolicyRuleArgs:
+class RegionSecurityPolicyRuleInitArgs:
     def __init__(__self__, *,
                  action: pulumi.Input[str],
                  priority: pulumi.Input[int],
@@ -780,7 +780,7 @@ class RegionSecurityPolicyRule(pulumi.CustomResource):
     @overload
     def __init__(__self__,
                  resource_name: str,
-                 args: RegionSecurityPolicyRuleArgs,
+                 args: RegionSecurityPolicyRuleInitArgs,
                  opts: Optional[pulumi.ResourceOptions] = None):
         """
         ## Example Usage
@@ -1026,12 +1026,12 @@ class RegionSecurityPolicyRule(pulumi.CustomResource):
         ```
 
         :param str resource_name: The name of the resource.
-        :param RegionSecurityPolicyRuleArgs args: The arguments to use to populate this resource's properties.
+        :param RegionSecurityPolicyRuleInitArgs args: The arguments to use to populate this resource's properties.
         :param pulumi.ResourceOptions opts: Options for the resource.
         """
         ...
     def __init__(__self__, resource_name: str, *args, **kwargs):
-        resource_args, opts = _utilities.get_resource_args_opts(RegionSecurityPolicyRuleArgs, pulumi.ResourceOptions, *args, **kwargs)
+        resource_args, opts = _utilities.get_resource_args_opts(RegionSecurityPolicyRuleInitArgs, pulumi.ResourceOptions, *args, **kwargs)
         if resource_args is not None:
             __self__._internal_init(resource_name, opts, **resource_args.__dict__)
         else:
@@ -1058,7 +1058,7 @@ class RegionSecurityPolicyRule(pulumi.CustomResource):
         if opts.id is None:
             if __props__ is not None:
                 raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource')
-            __props__ = RegionSecurityPolicyRuleArgs.__new__(RegionSecurityPolicyRuleArgs)
+            __props__ = RegionSecurityPolicyRuleInitArgs.__new__(RegionSecurityPolicyRuleInitArgs)
 
             if action is None and not opts.urn:
                 raise TypeError("Missing required property 'action'")

pulumi_gcp/compute/router_peer.py

@@ -81,11 +81,14 @@ class RouterPeerArgs:
                length, the routes with the lowest priority value win.
         :param pulumi.Input['RouterPeerBfdArgs'] bfd: BFD configuration for the BGP peering.
                Structure is documented below.
-        :param pulumi.Input[Sequence[pulumi.Input['RouterPeerCustomLearnedIpRangeArgs']]] custom_learned_ip_ranges: The custom learned route IP address range. Must be a valid CIDR-formatted prefix. If an IP address is provided without a
-               subnet mask, it is interpreted as, for IPv4, a /32 singular IP address range, and, for IPv6, /128.
-        :param pulumi.Input[int] custom_learned_route_priority: The user-defined custom learned route priority for a BGP session. This value is applied to all custom learned route
-               ranges for the session. You can choose a value from 0 to 65335. If you don't provide a value, Google Cloud assigns a
-               priority of 100 to the ranges.
+        :param pulumi.Input[Sequence[pulumi.Input['RouterPeerCustomLearnedIpRangeArgs']]] custom_learned_ip_ranges: The custom learned route IP address range. Must be a valid CIDR-formatted prefix.
+               If an IP address is provided without a subnet mask, it is interpreted as, for IPv4,
+               a /32 singular IP address range, and, for IPv6, /128.
+               Structure is documented below.
+        :param pulumi.Input[int] custom_learned_route_priority: The user-defined custom learned route priority for a BGP session.
+               This value is applied to all custom learned route ranges for the session.
+               You can choose a value from 0 to 65335. If you don't provide a value,
+               Google Cloud assigns a priority of 100 to the ranges.
         :param pulumi.Input[bool] enable: The status of the BGP peer connection. If set to false, any active session
                with the peer is terminated and all associated routing information is removed.
                If set to true, the peer connection can be established with routing information.
@@ -301,8 +304,10 @@ class RouterPeerArgs:
     @pulumi.getter(name="customLearnedIpRanges")
     def custom_learned_ip_ranges(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RouterPeerCustomLearnedIpRangeArgs']]]]:
         """
-        The custom learned route IP address range. Must be a valid CIDR-formatted prefix. If an IP address is provided without a
-        subnet mask, it is interpreted as, for IPv4, a /32 singular IP address range, and, for IPv6, /128.
+        The custom learned route IP address range. Must be a valid CIDR-formatted prefix.
+        If an IP address is provided without a subnet mask, it is interpreted as, for IPv4,
+        a /32 singular IP address range, and, for IPv6, /128.
+        Structure is documented below.
         """
         return pulumi.get(self, "custom_learned_ip_ranges")
 
@@ -314,9 +319,10 @@ class RouterPeerArgs:
     @pulumi.getter(name="customLearnedRoutePriority")
     def custom_learned_route_priority(self) -> Optional[pulumi.Input[int]]:
         """
-        The user-defined custom learned route priority for a BGP session. This value is applied to all custom learned route
-        ranges for the session. You can choose a value from 0 to 65335. If you don't provide a value, Google Cloud assigns a
-        priority of 100 to the ranges.
+        The user-defined custom learned route priority for a BGP session.
+        This value is applied to all custom learned route ranges for the session.
+        You can choose a value from 0 to 65335. If you don't provide a value,
+        Google Cloud assigns a priority of 100 to the ranges.
         """
         return pulumi.get(self, "custom_learned_route_priority")
 
@@ -598,11 +604,14 @@ class _RouterPeerState:
                length, the routes with the lowest priority value win.
         :param pulumi.Input['RouterPeerBfdArgs'] bfd: BFD configuration for the BGP peering.
                Structure is documented below.
-        :param pulumi.Input[Sequence[pulumi.Input['RouterPeerCustomLearnedIpRangeArgs']]] custom_learned_ip_ranges: The custom learned route IP address range. Must be a valid CIDR-formatted prefix. If an IP address is provided without a
-               subnet mask, it is interpreted as, for IPv4, a /32 singular IP address range, and, for IPv6, /128.
-        :param pulumi.Input[int] custom_learned_route_priority: The user-defined custom learned route priority for a BGP session. This value is applied to all custom learned route
-               ranges for the session. You can choose a value from 0 to 65335. If you don't provide a value, Google Cloud assigns a
-               priority of 100 to the ranges.
+        :param pulumi.Input[Sequence[pulumi.Input['RouterPeerCustomLearnedIpRangeArgs']]] custom_learned_ip_ranges: The custom learned route IP address range. Must be a valid CIDR-formatted prefix.
+               If an IP address is provided without a subnet mask, it is interpreted as, for IPv4,
+               a /32 singular IP address range, and, for IPv6, /128.
+               Structure is documented below.
+        :param pulumi.Input[int] custom_learned_route_priority: The user-defined custom learned route priority for a BGP session.
+               This value is applied to all custom learned route ranges for the session.
+               You can choose a value from 0 to 65335. If you don't provide a value,
+               Google Cloud assigns a priority of 100 to the ranges.
         :param pulumi.Input[bool] enable: The status of the BGP peer connection. If set to false, any active session
                with the peer is terminated and all associated routing information is removed.
                If set to true, the peer connection can be established with routing information.
@@ -799,8 +808,10 @@ class _RouterPeerState:
     @pulumi.getter(name="customLearnedIpRanges")
     def custom_learned_ip_ranges(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RouterPeerCustomLearnedIpRangeArgs']]]]:
         """
-        The custom learned route IP address range. Must be a valid CIDR-formatted prefix. If an IP address is provided without a
-        subnet mask, it is interpreted as, for IPv4, a /32 singular IP address range, and, for IPv6, /128.
+        The custom learned route IP address range. Must be a valid CIDR-formatted prefix.
+        If an IP address is provided without a subnet mask, it is interpreted as, for IPv4,
+        a /32 singular IP address range, and, for IPv6, /128.
+        Structure is documented below.
         """
         return pulumi.get(self, "custom_learned_ip_ranges")
 
@@ -812,9 +823,10 @@ class _RouterPeerState:
     @pulumi.getter(name="customLearnedRoutePriority")
     def custom_learned_route_priority(self) -> Optional[pulumi.Input[int]]:
         """
-        The user-defined custom learned route priority for a BGP session. This value is applied to all custom learned route
-        ranges for the session. You can choose a value from 0 to 65335. If you don't provide a value, Google Cloud assigns a
-        priority of 100 to the ranges.
+        The user-defined custom learned route priority for a BGP session.
+        This value is applied to all custom learned route ranges for the session.
+        You can choose a value from 0 to 65335. If you don't provide a value,
+        Google Cloud assigns a priority of 100 to the ranges.
         """
         return pulumi.get(self, "custom_learned_route_priority")
 
@@ -1465,11 +1477,14 @@ class RouterPeer(pulumi.CustomResource):
                length, the routes with the lowest priority value win.
         :param pulumi.Input[Union['RouterPeerBfdArgs', 'RouterPeerBfdArgsDict']] bfd: BFD configuration for the BGP peering.
                Structure is documented below.
-        :param pulumi.Input[Sequence[pulumi.Input[Union['RouterPeerCustomLearnedIpRangeArgs', 'RouterPeerCustomLearnedIpRangeArgsDict']]]] custom_learned_ip_ranges: The custom learned route IP address range. Must be a valid CIDR-formatted prefix. If an IP address is provided without a
-               subnet mask, it is interpreted as, for IPv4, a /32 singular IP address range, and, for IPv6, /128.
-        :param pulumi.Input[int] custom_learned_route_priority: The user-defined custom learned route priority for a BGP session. This value is applied to all custom learned route
-               ranges for the session. You can choose a value from 0 to 65335. If you don't provide a value, Google Cloud assigns a
-               priority of 100 to the ranges.
+        :param pulumi.Input[Sequence[pulumi.Input[Union['RouterPeerCustomLearnedIpRangeArgs', 'RouterPeerCustomLearnedIpRangeArgsDict']]]] custom_learned_ip_ranges: The custom learned route IP address range. Must be a valid CIDR-formatted prefix.
+               If an IP address is provided without a subnet mask, it is interpreted as, for IPv4,
+               a /32 singular IP address range, and, for IPv6, /128.
+               Structure is documented below.
+        :param pulumi.Input[int] custom_learned_route_priority: The user-defined custom learned route priority for a BGP session.
+               This value is applied to all custom learned route ranges for the session.
+               You can choose a value from 0 to 65335. If you don't provide a value,
+               Google Cloud assigns a priority of 100 to the ranges.
         :param pulumi.Input[bool] enable: The status of the BGP peer connection. If set to false, any active session
                with the peer is terminated and all associated routing information is removed.
                If set to true, the peer connection can be established with routing information.
@@ -1983,11 +1998,14 @@ class RouterPeer(pulumi.CustomResource):
                length, the routes with the lowest priority value win.
         :param pulumi.Input[Union['RouterPeerBfdArgs', 'RouterPeerBfdArgsDict']] bfd: BFD configuration for the BGP peering.
                Structure is documented below.
-        :param pulumi.Input[Sequence[pulumi.Input[Union['RouterPeerCustomLearnedIpRangeArgs', 'RouterPeerCustomLearnedIpRangeArgsDict']]]] custom_learned_ip_ranges: The custom learned route IP address range. Must be a valid CIDR-formatted prefix. If an IP address is provided without a
-               subnet mask, it is interpreted as, for IPv4, a /32 singular IP address range, and, for IPv6, /128.
-        :param pulumi.Input[int] custom_learned_route_priority: The user-defined custom learned route priority for a BGP session. This value is applied to all custom learned route
-               ranges for the session. You can choose a value from 0 to 65335. If you don't provide a value, Google Cloud assigns a
-               priority of 100 to the ranges.
+        :param pulumi.Input[Sequence[pulumi.Input[Union['RouterPeerCustomLearnedIpRangeArgs', 'RouterPeerCustomLearnedIpRangeArgsDict']]]] custom_learned_ip_ranges: The custom learned route IP address range. Must be a valid CIDR-formatted prefix.
+               If an IP address is provided without a subnet mask, it is interpreted as, for IPv4,
+               a /32 singular IP address range, and, for IPv6, /128.
+               Structure is documented below.
+        :param pulumi.Input[int] custom_learned_route_priority: The user-defined custom learned route priority for a BGP session.
+               This value is applied to all custom learned route ranges for the session.
+               You can choose a value from 0 to 65335. If you don't provide a value,
+               Google Cloud assigns a priority of 100 to the ranges.
         :param pulumi.Input[bool] enable: The status of the BGP peer connection. If set to false, any active session
                with the peer is terminated and all associated routing information is removed.
                If set to true, the peer connection can be established with routing information.
@@ -2142,8 +2160,10 @@ class RouterPeer(pulumi.CustomResource):
     @pulumi.getter(name="customLearnedIpRanges")
     def custom_learned_ip_ranges(self) -> pulumi.Output[Optional[Sequence['outputs.RouterPeerCustomLearnedIpRange']]]:
         """
-        The custom learned route IP address range. Must be a valid CIDR-formatted prefix. If an IP address is provided without a
-        subnet mask, it is interpreted as, for IPv4, a /32 singular IP address range, and, for IPv6, /128.
+        The custom learned route IP address range. Must be a valid CIDR-formatted prefix.
+        If an IP address is provided without a subnet mask, it is interpreted as, for IPv4,
+        a /32 singular IP address range, and, for IPv6, /128.
+        Structure is documented below.
         """
         return pulumi.get(self, "custom_learned_ip_ranges")
 
@@ -2151,9 +2171,10 @@ class RouterPeer(pulumi.CustomResource):
     @pulumi.getter(name="customLearnedRoutePriority")
     def custom_learned_route_priority(self) -> pulumi.Output[Optional[int]]:
         """
-        The user-defined custom learned route priority for a BGP session. This value is applied to all custom learned route
-        ranges for the session. You can choose a value from 0 to 65335. If you don't provide a value, Google Cloud assigns a
-        priority of 100 to the ranges.
+        The user-defined custom learned route priority for a BGP session.
+        This value is applied to all custom learned route ranges for the session.
+        You can choose a value from 0 to 65335. If you don't provide a value,
+        Google Cloud assigns a priority of 100 to the ranges.
         """
         return pulumi.get(self, "custom_learned_route_priority")
 

pulumi_gcp/compute/security_scan_config.py

@@ -470,20 +470,20 @@ class SecurityScanConfig(pulumi.CustomResource):
 
         ScanConfig can be imported using any of these accepted formats:
 
-        * `projects/{{project}}/scanConfigs/{{name}}`
-
         * `{{project}}/{{name}}`
 
+        * `{{project}} {{name}}`
+
         * `{{name}}`
 
         When using the `pulumi import` command, ScanConfig can be imported using one of the formats above. For example:
 
         ```sh
-        $ pulumi import gcp:compute/securityScanConfig:SecurityScanConfig default projects/{{project}}/scanConfigs/{{name}}
+        $ pulumi import gcp:compute/securityScanConfig:SecurityScanConfig default {{project}}/{{name}}
         ```
 
         ```sh
-        $ pulumi import gcp:compute/securityScanConfig:SecurityScanConfig default {{project}}/{{name}}
+        $ pulumi import gcp:compute/securityScanConfig:SecurityScanConfig default "{{project}} {{name}}"
         ```
 
         ```sh
@@ -551,20 +551,20 @@ class SecurityScanConfig(pulumi.CustomResource):
 
         ScanConfig can be imported using any of these accepted formats:
 
-        * `projects/{{project}}/scanConfigs/{{name}}`
-
         * `{{project}}/{{name}}`
 
+        * `{{project}} {{name}}`
+
         * `{{name}}`
 
         When using the `pulumi import` command, ScanConfig can be imported using one of the formats above. For example:
 
         ```sh
-        $ pulumi import gcp:compute/securityScanConfig:SecurityScanConfig default projects/{{project}}/scanConfigs/{{name}}
+        $ pulumi import gcp:compute/securityScanConfig:SecurityScanConfig default {{project}}/{{name}}
         ```
 
         ```sh
-        $ pulumi import gcp:compute/securityScanConfig:SecurityScanConfig default {{project}}/{{name}}
+        $ pulumi import gcp:compute/securityScanConfig:SecurityScanConfig default "{{project}} {{name}}"
         ```
 
         ```sh

pulumi_gcp/config/__init__.pyi

@@ -143,6 +143,8 @@ dataplexCustomEndpoint: Optional[str]
 
 dataprocCustomEndpoint: Optional[str]
 
+dataprocGdcCustomEndpoint: Optional[str]
+
 dataprocMetastoreCustomEndpoint: Optional[str]
 
 datastreamCustomEndpoint: Optional[str]
@@ -209,6 +211,8 @@ healthcareCustomEndpoint: Optional[str]
 
 iam2CustomEndpoint: Optional[str]
 
+iam3CustomEndpoint: Optional[str]
+
 iamBetaCustomEndpoint: Optional[str]
 
 iamCredentialsCustomEndpoint: Optional[str]

pulumi_gcp/config/vars.py

@@ -277,6 +277,10 @@ class _ExportableConfig(types.ModuleType):
     def dataproc_custom_endpoint(self) -> Optional[str]:
         return __config__.get('dataprocCustomEndpoint')
 
+    @property
+    def dataproc_gdc_custom_endpoint(self) -> Optional[str]:
+        return __config__.get('dataprocGdcCustomEndpoint')
+
     @property
     def dataproc_metastore_custom_endpoint(self) -> Optional[str]:
         return __config__.get('dataprocMetastoreCustomEndpoint')
@@ -409,6 +413,10 @@ class _ExportableConfig(types.ModuleType):
     def iam2_custom_endpoint(self) -> Optional[str]:
         return __config__.get('iam2CustomEndpoint')
 
+    @property
+    def iam3_custom_endpoint(self) -> Optional[str]:
+        return __config__.get('iam3CustomEndpoint')
+
     @property
     def iam_beta_custom_endpoint(self) -> Optional[str]:
         return __config__.get('iamBetaCustomEndpoint')