pulumi-gcp 7.24.0a1715926460__py3-none-any.whl → 7.24.0a1716510380__py3-none-any.whl

pulumi_gcp/compute/region_backend_service.py

@@ -89,6 +89,51 @@ class RegionBackendServiceArgs:
                Possible values are: `EXTERNAL`, `EXTERNAL_MANAGED`, `INTERNAL`, `INTERNAL_MANAGED`.
         :param pulumi.Input[str] locality_lb_policy: The load balancing algorithm used within the scope of the locality.
                The possible values are:
+               * `ROUND_ROBIN`: This is a simple policy in which each healthy backend
+               is selected in round robin order.
+               * `LEAST_REQUEST`: An O(1) algorithm which selects two random healthy
+               hosts and picks the host which has fewer active requests.
+               * `RING_HASH`: The ring/modulo hash load balancer implements consistent
+               hashing to backends. The algorithm has the property that the
+               addition/removal of a host from a set of N hosts only affects
+               1/N of the requests.
+               * `RANDOM`: The load balancer selects a random healthy host.
+               * `ORIGINAL_DESTINATION`: Backend host is selected based on the client
+               connection metadata, i.e., connections are opened
+               to the same address as the destination address of
+               the incoming connection before the connection
+               was redirected to the load balancer.
+               * `MAGLEV`: used as a drop in replacement for the ring hash load balancer.
+               Maglev is not as stable as ring hash but has faster table lookup
+               build times and host selection times. For more information about
+               Maglev, refer to https://ai.google/research/pubs/pub44824
+               * `WEIGHTED_MAGLEV`: Per-instance weighted Load Balancing via health check
+               reported weights. If set, the Backend Service must
+               configure a non legacy HTTP-based Health Check, and
+               health check replies are expected to contain
+               non-standard HTTP response header field
+               X-Load-Balancing-Endpoint-Weight to specify the
+               per-instance weights. If set, Load Balancing is weight
+               based on the per-instance weights reported in the last
+               processed health check replies, as long as every
+               instance either reported a valid weight or had
+               UNAVAILABLE_WEIGHT. Otherwise, Load Balancing remains
+               equal-weight.
+               
+               This field is applicable to either:
+               * A regional backend service with the service_protocol set to HTTP, HTTPS, or HTTP2,
+               and loadBalancingScheme set to INTERNAL_MANAGED.
+               * A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED.
+               * A regional backend service with loadBalancingScheme set to EXTERNAL (External Network
+               Load Balancing). Only MAGLEV and WEIGHTED_MAGLEV values are possible for External
+               Network Load Balancing. The default is MAGLEV.
+               
+               If session_affinity is not NONE, and this field is not set to MAGLEV, WEIGHTED_MAGLEV,
+               or RING_HASH, session affinity settings will not take effect.
+               Only ROUND_ROBIN and RING_HASH are supported when the backend service is referenced
+               by a URL map that is bound to target gRPC proxy that has validate_for_proxyless
+               field set to true.
+               Possible values are: `ROUND_ROBIN`, `LEAST_REQUEST`, `RING_HASH`, `RANDOM`, `ORIGINAL_DESTINATION`, `MAGLEV`, `WEIGHTED_MAGLEV`.
         :param pulumi.Input['RegionBackendServiceLogConfigArgs'] log_config: This field denotes the logging options for the load balancer traffic served by this backend service.
                If logging is enabled, logs will be exported to Stackdriver.
                Structure is documented below.
@@ -377,6 +422,51 @@ class RegionBackendServiceArgs:
         """
         The load balancing algorithm used within the scope of the locality.
         The possible values are:
+        * `ROUND_ROBIN`: This is a simple policy in which each healthy backend
+        is selected in round robin order.
+        * `LEAST_REQUEST`: An O(1) algorithm which selects two random healthy
+        hosts and picks the host which has fewer active requests.
+        * `RING_HASH`: The ring/modulo hash load balancer implements consistent
+        hashing to backends. The algorithm has the property that the
+        addition/removal of a host from a set of N hosts only affects
+        1/N of the requests.
+        * `RANDOM`: The load balancer selects a random healthy host.
+        * `ORIGINAL_DESTINATION`: Backend host is selected based on the client
+        connection metadata, i.e., connections are opened
+        to the same address as the destination address of
+        the incoming connection before the connection
+        was redirected to the load balancer.
+        * `MAGLEV`: used as a drop in replacement for the ring hash load balancer.
+        Maglev is not as stable as ring hash but has faster table lookup
+        build times and host selection times. For more information about
+        Maglev, refer to https://ai.google/research/pubs/pub44824
+        * `WEIGHTED_MAGLEV`: Per-instance weighted Load Balancing via health check
+        reported weights. If set, the Backend Service must
+        configure a non legacy HTTP-based Health Check, and
+        health check replies are expected to contain
+        non-standard HTTP response header field
+        X-Load-Balancing-Endpoint-Weight to specify the
+        per-instance weights. If set, Load Balancing is weight
+        based on the per-instance weights reported in the last
+        processed health check replies, as long as every
+        instance either reported a valid weight or had
+        UNAVAILABLE_WEIGHT. Otherwise, Load Balancing remains
+        equal-weight.
+
+        This field is applicable to either:
+        * A regional backend service with the service_protocol set to HTTP, HTTPS, or HTTP2,
+        and loadBalancingScheme set to INTERNAL_MANAGED.
+        * A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED.
+        * A regional backend service with loadBalancingScheme set to EXTERNAL (External Network
+        Load Balancing). Only MAGLEV and WEIGHTED_MAGLEV values are possible for External
+        Network Load Balancing. The default is MAGLEV.
+
+        If session_affinity is not NONE, and this field is not set to MAGLEV, WEIGHTED_MAGLEV,
+        or RING_HASH, session affinity settings will not take effect.
+        Only ROUND_ROBIN and RING_HASH are supported when the backend service is referenced
+        by a URL map that is bound to target gRPC proxy that has validate_for_proxyless
+        field set to true.
+        Possible values are: `ROUND_ROBIN`, `LEAST_REQUEST`, `RING_HASH`, `RANDOM`, `ORIGINAL_DESTINATION`, `MAGLEV`, `WEIGHTED_MAGLEV`.
         """
         return pulumi.get(self, "locality_lb_policy")
 
@@ -643,6 +733,51 @@ class _RegionBackendServiceState:
                Possible values are: `EXTERNAL`, `EXTERNAL_MANAGED`, `INTERNAL`, `INTERNAL_MANAGED`.
         :param pulumi.Input[str] locality_lb_policy: The load balancing algorithm used within the scope of the locality.
                The possible values are:
+               * `ROUND_ROBIN`: This is a simple policy in which each healthy backend
+               is selected in round robin order.
+               * `LEAST_REQUEST`: An O(1) algorithm which selects two random healthy
+               hosts and picks the host which has fewer active requests.
+               * `RING_HASH`: The ring/modulo hash load balancer implements consistent
+               hashing to backends. The algorithm has the property that the
+               addition/removal of a host from a set of N hosts only affects
+               1/N of the requests.
+               * `RANDOM`: The load balancer selects a random healthy host.
+               * `ORIGINAL_DESTINATION`: Backend host is selected based on the client
+               connection metadata, i.e., connections are opened
+               to the same address as the destination address of
+               the incoming connection before the connection
+               was redirected to the load balancer.
+               * `MAGLEV`: used as a drop in replacement for the ring hash load balancer.
+               Maglev is not as stable as ring hash but has faster table lookup
+               build times and host selection times. For more information about
+               Maglev, refer to https://ai.google/research/pubs/pub44824
+               * `WEIGHTED_MAGLEV`: Per-instance weighted Load Balancing via health check
+               reported weights. If set, the Backend Service must
+               configure a non legacy HTTP-based Health Check, and
+               health check replies are expected to contain
+               non-standard HTTP response header field
+               X-Load-Balancing-Endpoint-Weight to specify the
+               per-instance weights. If set, Load Balancing is weight
+               based on the per-instance weights reported in the last
+               processed health check replies, as long as every
+               instance either reported a valid weight or had
+               UNAVAILABLE_WEIGHT. Otherwise, Load Balancing remains
+               equal-weight.
+               
+               This field is applicable to either:
+               * A regional backend service with the service_protocol set to HTTP, HTTPS, or HTTP2,
+               and loadBalancingScheme set to INTERNAL_MANAGED.
+               * A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED.
+               * A regional backend service with loadBalancingScheme set to EXTERNAL (External Network
+               Load Balancing). Only MAGLEV and WEIGHTED_MAGLEV values are possible for External
+               Network Load Balancing. The default is MAGLEV.
+               
+               If session_affinity is not NONE, and this field is not set to MAGLEV, WEIGHTED_MAGLEV,
+               or RING_HASH, session affinity settings will not take effect.
+               Only ROUND_ROBIN and RING_HASH are supported when the backend service is referenced
+               by a URL map that is bound to target gRPC proxy that has validate_for_proxyless
+               field set to true.
+               Possible values are: `ROUND_ROBIN`, `LEAST_REQUEST`, `RING_HASH`, `RANDOM`, `ORIGINAL_DESTINATION`, `MAGLEV`, `WEIGHTED_MAGLEV`.
         :param pulumi.Input['RegionBackendServiceLogConfigArgs'] log_config: This field denotes the logging options for the load balancer traffic served by this backend service.
                If logging is enabled, logs will be exported to Stackdriver.
                Structure is documented below.
@@ -977,6 +1112,51 @@ class _RegionBackendServiceState:
         """
         The load balancing algorithm used within the scope of the locality.
         The possible values are:
+        * `ROUND_ROBIN`: This is a simple policy in which each healthy backend
+        is selected in round robin order.
+        * `LEAST_REQUEST`: An O(1) algorithm which selects two random healthy
+        hosts and picks the host which has fewer active requests.
+        * `RING_HASH`: The ring/modulo hash load balancer implements consistent
+        hashing to backends. The algorithm has the property that the
+        addition/removal of a host from a set of N hosts only affects
+        1/N of the requests.
+        * `RANDOM`: The load balancer selects a random healthy host.
+        * `ORIGINAL_DESTINATION`: Backend host is selected based on the client
+        connection metadata, i.e., connections are opened
+        to the same address as the destination address of
+        the incoming connection before the connection
+        was redirected to the load balancer.
+        * `MAGLEV`: used as a drop in replacement for the ring hash load balancer.
+        Maglev is not as stable as ring hash but has faster table lookup
+        build times and host selection times. For more information about
+        Maglev, refer to https://ai.google/research/pubs/pub44824
+        * `WEIGHTED_MAGLEV`: Per-instance weighted Load Balancing via health check
+        reported weights. If set, the Backend Service must
+        configure a non legacy HTTP-based Health Check, and
+        health check replies are expected to contain
+        non-standard HTTP response header field
+        X-Load-Balancing-Endpoint-Weight to specify the
+        per-instance weights. If set, Load Balancing is weight
+        based on the per-instance weights reported in the last
+        processed health check replies, as long as every
+        instance either reported a valid weight or had
+        UNAVAILABLE_WEIGHT. Otherwise, Load Balancing remains
+        equal-weight.
+
+        This field is applicable to either:
+        * A regional backend service with the service_protocol set to HTTP, HTTPS, or HTTP2,
+        and loadBalancingScheme set to INTERNAL_MANAGED.
+        * A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED.
+        * A regional backend service with loadBalancingScheme set to EXTERNAL (External Network
+        Load Balancing). Only MAGLEV and WEIGHTED_MAGLEV values are possible for External
+        Network Load Balancing. The default is MAGLEV.
+
+        If session_affinity is not NONE, and this field is not set to MAGLEV, WEIGHTED_MAGLEV,
+        or RING_HASH, session affinity settings will not take effect.
+        Only ROUND_ROBIN and RING_HASH are supported when the backend service is referenced
+        by a URL map that is bound to target gRPC proxy that has validate_for_proxyless
+        field set to true.
+        Possible values are: `ROUND_ROBIN`, `LEAST_REQUEST`, `RING_HASH`, `RANDOM`, `ORIGINAL_DESTINATION`, `MAGLEV`, `WEIGHTED_MAGLEV`.
         """
         return pulumi.get(self, "locality_lb_policy")
 
@@ -1538,6 +1718,51 @@ class RegionBackendService(pulumi.CustomResource):
                Possible values are: `EXTERNAL`, `EXTERNAL_MANAGED`, `INTERNAL`, `INTERNAL_MANAGED`.
         :param pulumi.Input[str] locality_lb_policy: The load balancing algorithm used within the scope of the locality.
                The possible values are:
+               * `ROUND_ROBIN`: This is a simple policy in which each healthy backend
+               is selected in round robin order.
+               * `LEAST_REQUEST`: An O(1) algorithm which selects two random healthy
+               hosts and picks the host which has fewer active requests.
+               * `RING_HASH`: The ring/modulo hash load balancer implements consistent
+               hashing to backends. The algorithm has the property that the
+               addition/removal of a host from a set of N hosts only affects
+               1/N of the requests.
+               * `RANDOM`: The load balancer selects a random healthy host.
+               * `ORIGINAL_DESTINATION`: Backend host is selected based on the client
+               connection metadata, i.e., connections are opened
+               to the same address as the destination address of
+               the incoming connection before the connection
+               was redirected to the load balancer.
+               * `MAGLEV`: used as a drop in replacement for the ring hash load balancer.
+               Maglev is not as stable as ring hash but has faster table lookup
+               build times and host selection times. For more information about
+               Maglev, refer to https://ai.google/research/pubs/pub44824
+               * `WEIGHTED_MAGLEV`: Per-instance weighted Load Balancing via health check
+               reported weights. If set, the Backend Service must
+               configure a non legacy HTTP-based Health Check, and
+               health check replies are expected to contain
+               non-standard HTTP response header field
+               X-Load-Balancing-Endpoint-Weight to specify the
+               per-instance weights. If set, Load Balancing is weight
+               based on the per-instance weights reported in the last
+               processed health check replies, as long as every
+               instance either reported a valid weight or had
+               UNAVAILABLE_WEIGHT. Otherwise, Load Balancing remains
+               equal-weight.
+               
+               This field is applicable to either:
+               * A regional backend service with the service_protocol set to HTTP, HTTPS, or HTTP2,
+               and loadBalancingScheme set to INTERNAL_MANAGED.
+               * A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED.
+               * A regional backend service with loadBalancingScheme set to EXTERNAL (External Network
+               Load Balancing). Only MAGLEV and WEIGHTED_MAGLEV values are possible for External
+               Network Load Balancing. The default is MAGLEV.
+               
+               If session_affinity is not NONE, and this field is not set to MAGLEV, WEIGHTED_MAGLEV,
+               or RING_HASH, session affinity settings will not take effect.
+               Only ROUND_ROBIN and RING_HASH are supported when the backend service is referenced
+               by a URL map that is bound to target gRPC proxy that has validate_for_proxyless
+               field set to true.
+               Possible values are: `ROUND_ROBIN`, `LEAST_REQUEST`, `RING_HASH`, `RANDOM`, `ORIGINAL_DESTINATION`, `MAGLEV`, `WEIGHTED_MAGLEV`.
         :param pulumi.Input[pulumi.InputType['RegionBackendServiceLogConfigArgs']] log_config: This field denotes the logging options for the load balancer traffic served by this backend service.
                If logging is enabled, logs will be exported to Stackdriver.
                Structure is documented below.
@@ -2051,6 +2276,51 @@ class RegionBackendService(pulumi.CustomResource):
                Possible values are: `EXTERNAL`, `EXTERNAL_MANAGED`, `INTERNAL`, `INTERNAL_MANAGED`.
         :param pulumi.Input[str] locality_lb_policy: The load balancing algorithm used within the scope of the locality.
                The possible values are:
+               * `ROUND_ROBIN`: This is a simple policy in which each healthy backend
+               is selected in round robin order.
+               * `LEAST_REQUEST`: An O(1) algorithm which selects two random healthy
+               hosts and picks the host which has fewer active requests.
+               * `RING_HASH`: The ring/modulo hash load balancer implements consistent
+               hashing to backends. The algorithm has the property that the
+               addition/removal of a host from a set of N hosts only affects
+               1/N of the requests.
+               * `RANDOM`: The load balancer selects a random healthy host.
+               * `ORIGINAL_DESTINATION`: Backend host is selected based on the client
+               connection metadata, i.e., connections are opened
+               to the same address as the destination address of
+               the incoming connection before the connection
+               was redirected to the load balancer.
+               * `MAGLEV`: used as a drop in replacement for the ring hash load balancer.
+               Maglev is not as stable as ring hash but has faster table lookup
+               build times and host selection times. For more information about
+               Maglev, refer to https://ai.google/research/pubs/pub44824
+               * `WEIGHTED_MAGLEV`: Per-instance weighted Load Balancing via health check
+               reported weights. If set, the Backend Service must
+               configure a non legacy HTTP-based Health Check, and
+               health check replies are expected to contain
+               non-standard HTTP response header field
+               X-Load-Balancing-Endpoint-Weight to specify the
+               per-instance weights. If set, Load Balancing is weight
+               based on the per-instance weights reported in the last
+               processed health check replies, as long as every
+               instance either reported a valid weight or had
+               UNAVAILABLE_WEIGHT. Otherwise, Load Balancing remains
+               equal-weight.
+               
+               This field is applicable to either:
+               * A regional backend service with the service_protocol set to HTTP, HTTPS, or HTTP2,
+               and loadBalancingScheme set to INTERNAL_MANAGED.
+               * A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED.
+               * A regional backend service with loadBalancingScheme set to EXTERNAL (External Network
+               Load Balancing). Only MAGLEV and WEIGHTED_MAGLEV values are possible for External
+               Network Load Balancing. The default is MAGLEV.
+               
+               If session_affinity is not NONE, and this field is not set to MAGLEV, WEIGHTED_MAGLEV,
+               or RING_HASH, session affinity settings will not take effect.
+               Only ROUND_ROBIN and RING_HASH are supported when the backend service is referenced
+               by a URL map that is bound to target gRPC proxy that has validate_for_proxyless
+               field set to true.
+               Possible values are: `ROUND_ROBIN`, `LEAST_REQUEST`, `RING_HASH`, `RANDOM`, `ORIGINAL_DESTINATION`, `MAGLEV`, `WEIGHTED_MAGLEV`.
         :param pulumi.Input[pulumi.InputType['RegionBackendServiceLogConfigArgs']] log_config: This field denotes the logging options for the load balancer traffic served by this backend service.
                If logging is enabled, logs will be exported to Stackdriver.
                Structure is documented below.
@@ -2296,6 +2566,51 @@ class RegionBackendService(pulumi.CustomResource):
         """
         The load balancing algorithm used within the scope of the locality.
         The possible values are:
+        * `ROUND_ROBIN`: This is a simple policy in which each healthy backend
+        is selected in round robin order.
+        * `LEAST_REQUEST`: An O(1) algorithm which selects two random healthy
+        hosts and picks the host which has fewer active requests.
+        * `RING_HASH`: The ring/modulo hash load balancer implements consistent
+        hashing to backends. The algorithm has the property that the
+        addition/removal of a host from a set of N hosts only affects
+        1/N of the requests.
+        * `RANDOM`: The load balancer selects a random healthy host.
+        * `ORIGINAL_DESTINATION`: Backend host is selected based on the client
+        connection metadata, i.e., connections are opened
+        to the same address as the destination address of
+        the incoming connection before the connection
+        was redirected to the load balancer.
+        * `MAGLEV`: used as a drop in replacement for the ring hash load balancer.
+        Maglev is not as stable as ring hash but has faster table lookup
+        build times and host selection times. For more information about
+        Maglev, refer to https://ai.google/research/pubs/pub44824
+        * `WEIGHTED_MAGLEV`: Per-instance weighted Load Balancing via health check
+        reported weights. If set, the Backend Service must
+        configure a non legacy HTTP-based Health Check, and
+        health check replies are expected to contain
+        non-standard HTTP response header field
+        X-Load-Balancing-Endpoint-Weight to specify the
+        per-instance weights. If set, Load Balancing is weight
+        based on the per-instance weights reported in the last
+        processed health check replies, as long as every
+        instance either reported a valid weight or had
+        UNAVAILABLE_WEIGHT. Otherwise, Load Balancing remains
+        equal-weight.
+
+        This field is applicable to either:
+        * A regional backend service with the service_protocol set to HTTP, HTTPS, or HTTP2,
+        and loadBalancingScheme set to INTERNAL_MANAGED.
+        * A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED.
+        * A regional backend service with loadBalancingScheme set to EXTERNAL (External Network
+        Load Balancing). Only MAGLEV and WEIGHTED_MAGLEV values are possible for External
+        Network Load Balancing. The default is MAGLEV.
+
+        If session_affinity is not NONE, and this field is not set to MAGLEV, WEIGHTED_MAGLEV,
+        or RING_HASH, session affinity settings will not take effect.
+        Only ROUND_ROBIN and RING_HASH are supported when the backend service is referenced
+        by a URL map that is bound to target gRPC proxy that has validate_for_proxyless
+        field set to true.
+        Possible values are: `ROUND_ROBIN`, `LEAST_REQUEST`, `RING_HASH`, `RANDOM`, `ORIGINAL_DESTINATION`, `MAGLEV`, `WEIGHTED_MAGLEV`.
         """
         return pulumi.get(self, "locality_lb_policy")
 

pulumi_gcp/compute/router_peer.py

@@ -53,6 +53,14 @@ class RouterPeerArgs:
                Possible values are: `DEFAULT`, `CUSTOM`.
         :param pulumi.Input[Sequence[pulumi.Input[str]]] advertised_groups: User-specified list of prefix groups to advertise in custom
                mode, which currently supports the following option:
+               * `ALL_SUBNETS`: Advertises all of the router's own VPC subnets.
+               This excludes any routes learned for subnets that use VPC Network
+               Peering.
+               
+               Note that this field can only be populated if advertiseMode is `CUSTOM`
+               and overrides the list defined for the router (in the "bgp" message).
+               These groups are advertised in addition to any specified prefixes.
+               Leave this field blank to advertise no custom groups.
         :param pulumi.Input[Sequence[pulumi.Input['RouterPeerAdvertisedIpRangeArgs']]] advertised_ip_ranges: User-specified list of individual IP ranges to advertise in
                custom mode. This field can only be populated if advertiseMode
                is `CUSTOM` and is advertised to all peers of the router. These IP
@@ -204,6 +212,14 @@ class RouterPeerArgs:
         """
         User-specified list of prefix groups to advertise in custom
         mode, which currently supports the following option:
+        * `ALL_SUBNETS`: Advertises all of the router's own VPC subnets.
+        This excludes any routes learned for subnets that use VPC Network
+        Peering.
+
+        Note that this field can only be populated if advertiseMode is `CUSTOM`
+        and overrides the list defined for the router (in the "bgp" message).
+        These groups are advertised in addition to any specified prefixes.
+        Leave this field blank to advertise no custom groups.
         """
         return pulumi.get(self, "advertised_groups")
 
@@ -480,6 +496,14 @@ class _RouterPeerState:
                Possible values are: `DEFAULT`, `CUSTOM`.
         :param pulumi.Input[Sequence[pulumi.Input[str]]] advertised_groups: User-specified list of prefix groups to advertise in custom
                mode, which currently supports the following option:
+               * `ALL_SUBNETS`: Advertises all of the router's own VPC subnets.
+               This excludes any routes learned for subnets that use VPC Network
+               Peering.
+               
+               Note that this field can only be populated if advertiseMode is `CUSTOM`
+               and overrides the list defined for the router (in the "bgp" message).
+               These groups are advertised in addition to any specified prefixes.
+               Leave this field blank to advertise no custom groups.
         :param pulumi.Input[Sequence[pulumi.Input['RouterPeerAdvertisedIpRangeArgs']]] advertised_ip_ranges: User-specified list of individual IP ranges to advertise in
                custom mode. This field can only be populated if advertiseMode
                is `CUSTOM` and is advertised to all peers of the router. These IP
@@ -506,6 +530,14 @@ class _RouterPeerState:
                If you do not specify the next hop addresses, Google Cloud automatically
                assigns unused addresses from the 2600:2d00:0:2::/64 or 2600:2d00:0:3::/64 range for you.
         :param pulumi.Input[str] management_type: The resource that configures and manages this BGP peer.
+               * `MANAGED_BY_USER` is the default value and can be managed by
+               you or other users
+               * `MANAGED_BY_ATTACHMENT` is a BGP peer that is configured and
+               managed by Cloud Interconnect, specifically by an
+               InterconnectAttachment of type PARTNER. Google automatically
+               creates, updates, and deletes this type of BGP peer when the
+               PARTNER InterconnectAttachment is created, updated,
+               or deleted.
         :param pulumi.Input['RouterPeerMd5AuthenticationKeyArgs'] md5_authentication_key: Configuration for MD5 authentication on the BGP session.
                Structure is documented below.
         :param pulumi.Input[str] name: Name of this BGP peer. The name must be 1-63 characters long,
@@ -604,6 +636,14 @@ class _RouterPeerState:
         """
         User-specified list of prefix groups to advertise in custom
         mode, which currently supports the following option:
+        * `ALL_SUBNETS`: Advertises all of the router's own VPC subnets.
+        This excludes any routes learned for subnets that use VPC Network
+        Peering.
+
+        Note that this field can only be populated if advertiseMode is `CUSTOM`
+        and overrides the list defined for the router (in the "bgp" message).
+        These groups are advertised in addition to any specified prefixes.
+        Leave this field blank to advertise no custom groups.
         """
         return pulumi.get(self, "advertised_groups")
 
@@ -751,6 +791,14 @@ class _RouterPeerState:
     def management_type(self) -> Optional[pulumi.Input[str]]:
         """
         The resource that configures and manages this BGP peer.
+        * `MANAGED_BY_USER` is the default value and can be managed by
+        you or other users
+        * `MANAGED_BY_ATTACHMENT` is a BGP peer that is configured and
+        managed by Cloud Interconnect, specifically by an
+        InterconnectAttachment of type PARTNER. Google automatically
+        creates, updates, and deletes this type of BGP peer when the
+        PARTNER InterconnectAttachment is created, updated,
+        or deleted.
         """
         return pulumi.get(self, "management_type")
 
@@ -1134,6 +1182,14 @@ class RouterPeer(pulumi.CustomResource):
                Possible values are: `DEFAULT`, `CUSTOM`.
         :param pulumi.Input[Sequence[pulumi.Input[str]]] advertised_groups: User-specified list of prefix groups to advertise in custom
                mode, which currently supports the following option:
+               * `ALL_SUBNETS`: Advertises all of the router's own VPC subnets.
+               This excludes any routes learned for subnets that use VPC Network
+               Peering.
+               
+               Note that this field can only be populated if advertiseMode is `CUSTOM`
+               and overrides the list defined for the router (in the "bgp" message).
+               These groups are advertised in addition to any specified prefixes.
+               Leave this field blank to advertise no custom groups.
         :param pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['RouterPeerAdvertisedIpRangeArgs']]]] advertised_ip_ranges: User-specified list of individual IP ranges to advertise in
                custom mode. This field can only be populated if advertiseMode
                is `CUSTOM` and is advertised to all peers of the router. These IP
@@ -1516,6 +1572,14 @@ class RouterPeer(pulumi.CustomResource):
                Possible values are: `DEFAULT`, `CUSTOM`.
         :param pulumi.Input[Sequence[pulumi.Input[str]]] advertised_groups: User-specified list of prefix groups to advertise in custom
                mode, which currently supports the following option:
+               * `ALL_SUBNETS`: Advertises all of the router's own VPC subnets.
+               This excludes any routes learned for subnets that use VPC Network
+               Peering.
+               
+               Note that this field can only be populated if advertiseMode is `CUSTOM`
+               and overrides the list defined for the router (in the "bgp" message).
+               These groups are advertised in addition to any specified prefixes.
+               Leave this field blank to advertise no custom groups.
         :param pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['RouterPeerAdvertisedIpRangeArgs']]]] advertised_ip_ranges: User-specified list of individual IP ranges to advertise in
                custom mode. This field can only be populated if advertiseMode
                is `CUSTOM` and is advertised to all peers of the router. These IP
@@ -1542,6 +1606,14 @@ class RouterPeer(pulumi.CustomResource):
                If you do not specify the next hop addresses, Google Cloud automatically
                assigns unused addresses from the 2600:2d00:0:2::/64 or 2600:2d00:0:3::/64 range for you.
         :param pulumi.Input[str] management_type: The resource that configures and manages this BGP peer.
+               * `MANAGED_BY_USER` is the default value and can be managed by
+               you or other users
+               * `MANAGED_BY_ATTACHMENT` is a BGP peer that is configured and
+               managed by Cloud Interconnect, specifically by an
+               InterconnectAttachment of type PARTNER. Google automatically
+               creates, updates, and deletes this type of BGP peer when the
+               PARTNER InterconnectAttachment is created, updated,
+               or deleted.
         :param pulumi.Input[pulumi.InputType['RouterPeerMd5AuthenticationKeyArgs']] md5_authentication_key: Configuration for MD5 authentication on the BGP session.
                Structure is documented below.
         :param pulumi.Input[str] name: Name of this BGP peer. The name must be 1-63 characters long,
@@ -1618,6 +1690,14 @@ class RouterPeer(pulumi.CustomResource):
         """
         User-specified list of prefix groups to advertise in custom
         mode, which currently supports the following option:
+        * `ALL_SUBNETS`: Advertises all of the router's own VPC subnets.
+        This excludes any routes learned for subnets that use VPC Network
+        Peering.
+
+        Note that this field can only be populated if advertiseMode is `CUSTOM`
+        and overrides the list defined for the router (in the "bgp" message).
+        These groups are advertised in addition to any specified prefixes.
+        Leave this field blank to advertise no custom groups.
         """
         return pulumi.get(self, "advertised_groups")
 
@@ -1721,6 +1801,14 @@ class RouterPeer(pulumi.CustomResource):
     def management_type(self) -> pulumi.Output[str]:
         """
         The resource that configures and manages this BGP peer.
+        * `MANAGED_BY_USER` is the default value and can be managed by
+        you or other users
+        * `MANAGED_BY_ATTACHMENT` is a BGP peer that is configured and
+        managed by Cloud Interconnect, specifically by an
+        InterconnectAttachment of type PARTNER. Google automatically
+        creates, updates, and deletes this type of BGP peer when the
+        PARTNER InterconnectAttachment is created, updated,
+        or deleted.
         """
         return pulumi.get(self, "management_type")
 

pulumi_gcp/compute/security_policy.py

@@ -40,6 +40,13 @@ class SecurityPolicyArgs:
                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. This field can be set only at resource creation time.
+               * `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.
+               * `CLOUD_ARMOR_INTERNAL_SERVICE` - Cloud Armor internal service policies can be configured to filter HTTP requests targeting services
+               managed by Traffic Director in a service mesh. They filter requests before the request is served from the application.
         """
         if adaptive_protection_config is not None:
             pulumi.set(__self__, "adaptive_protection_config", adaptive_protection_config)
@@ -153,6 +160,13 @@ class SecurityPolicyArgs:
     def type(self) -> Optional[pulumi.Input[str]]:
         """
         The type indicates the intended use of the security policy. This field can be set only at resource creation time.
+        * `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.
+        * `CLOUD_ARMOR_INTERNAL_SERVICE` - Cloud Armor internal service policies can be configured to filter HTTP requests targeting services
+        managed by Traffic Director in a service mesh. They filter requests before the request is served from the application.
         """
         return pulumi.get(self, "type")
 
@@ -192,6 +206,13 @@ class _SecurityPolicyState:
                security policy, a default rule with action "allow" will be added. Structure is documented below.
         :param pulumi.Input[str] self_link: The URI of the created resource.
         :param pulumi.Input[str] type: The type indicates the intended use of the security policy. This field can be set only at resource creation time.
+               * `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.
+               * `CLOUD_ARMOR_INTERNAL_SERVICE` - Cloud Armor internal service policies can be configured to filter HTTP requests targeting services
+               managed by Traffic Director in a service mesh. They filter requests before the request is served from the application.
         """
         if adaptive_protection_config is not None:
             pulumi.set(__self__, "adaptive_protection_config", adaptive_protection_config)
@@ -333,6 +354,13 @@ class _SecurityPolicyState:
     def type(self) -> Optional[pulumi.Input[str]]:
         """
         The type indicates the intended use of the security policy. This field can be set only at resource creation time.
+        * `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.
+        * `CLOUD_ARMOR_INTERNAL_SERVICE` - Cloud Armor internal service policies can be configured to filter HTTP requests targeting services
+        managed by Traffic Director in a service mesh. They filter requests before the request is served from the application.
         """
         return pulumi.get(self, "type")
 
@@ -545,6 +573,13 @@ class SecurityPolicy(pulumi.CustomResource):
                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. This field can be set only at resource creation time.
+               * `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.
+               * `CLOUD_ARMOR_INTERNAL_SERVICE` - Cloud Armor internal service policies can be configured to filter HTTP requests targeting services
+               managed by Traffic Director in a service mesh. They filter requests before the request is served from the application.
         """
         ...
     @overload
@@ -811,6 +846,13 @@ class SecurityPolicy(pulumi.CustomResource):
                security policy, a default rule with action "allow" will be added. Structure is documented below.
         :param pulumi.Input[str] self_link: The URI of the created resource.
         :param pulumi.Input[str] type: The type indicates the intended use of the security policy. This field can be set only at resource creation time.
+               * `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.
+               * `CLOUD_ARMOR_INTERNAL_SERVICE` - Cloud Armor internal service policies can be configured to filter HTTP requests targeting services
+               managed by Traffic Director in a service mesh. They filter requests before the request is served from the application.
         """
         opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
 
@@ -911,6 +953,13 @@ class SecurityPolicy(pulumi.CustomResource):
     def type(self) -> pulumi.Output[str]:
         """
         The type indicates the intended use of the security policy. This field can be set only at resource creation time.
+        * `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.
+        * `CLOUD_ARMOR_INTERNAL_SERVICE` - Cloud Armor internal service policies can be configured to filter HTTP requests targeting services
+        managed by Traffic Director in a service mesh. They filter requests before the request is served from the application.
         """
         return pulumi.get(self, "type")