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

pulumi_gcp/compute/backend_service.py

@@ -100,6 +100,51 @@ class BackendServiceArgs:
                Structure is documented below.
         :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['BackendServiceLogConfigArgs'] 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.
@@ -430,6 +475,51 @@ class BackendServiceArgs:
         """
         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")
 
@@ -682,6 +772,51 @@ class _BackendServiceState:
                Structure is documented below.
         :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['BackendServiceLogConfigArgs'] 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.
@@ -1058,6 +1193,51 @@ class _BackendServiceState:
         """
         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")
 
@@ -1598,6 +1778,51 @@ class BackendService(pulumi.CustomResource):
                Structure is documented below.
         :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['BackendServiceLogConfigArgs']] 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.
@@ -2114,6 +2339,51 @@ class BackendService(pulumi.CustomResource):
                Structure is documented below.
         :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['BackendServiceLogConfigArgs']] 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.
@@ -2388,6 +2658,51 @@ class BackendService(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")