pulumi-gcp 8.41.0a1755408441__py3-none-any.whl → 8.41.0a1755714744__py3-none-any.whl

pulumi_gcp/compute/_inputs.py

@@ -739,6 +739,12 @@ __all__ = [
     'RegionBackendServiceDynamicForwardingIpPortSelectionArgsDict',
     'RegionBackendServiceFailoverPolicyArgs',
     'RegionBackendServiceFailoverPolicyArgsDict',
+    'RegionBackendServiceHaPolicyArgs',
+    'RegionBackendServiceHaPolicyArgsDict',
+    'RegionBackendServiceHaPolicyLeaderArgs',
+    'RegionBackendServiceHaPolicyLeaderArgsDict',
+    'RegionBackendServiceHaPolicyLeaderNetworkEndpointArgs',
+    'RegionBackendServiceHaPolicyLeaderNetworkEndpointArgsDict',
     'RegionBackendServiceIamBindingConditionArgs',
     'RegionBackendServiceIamBindingConditionArgsDict',
     'RegionBackendServiceIamMemberConditionArgs',
@@ -963,6 +969,10 @@ __all__ = [
     'RegionResizeRequestStatusLastAttemptErrorErrorErrorDetailLocalizedMessageArgsDict',
     'RegionResizeRequestStatusLastAttemptErrorErrorErrorDetailQuotaInfoArgs',
     'RegionResizeRequestStatusLastAttemptErrorErrorErrorDetailQuotaInfoArgsDict',
+    'RegionSecurityPolicyAdvancedOptionsConfigArgs',
+    'RegionSecurityPolicyAdvancedOptionsConfigArgsDict',
+    'RegionSecurityPolicyAdvancedOptionsConfigJsonCustomConfigArgs',
+    'RegionSecurityPolicyAdvancedOptionsConfigJsonCustomConfigArgsDict',
     'RegionSecurityPolicyDdosProtectionConfigArgs',
     'RegionSecurityPolicyDdosProtectionConfigArgsDict',
     'RegionSecurityPolicyRuleArgs',
@@ -37986,6 +37996,193 @@ class RegionBackendServiceFailoverPolicyArgs:
         pulumi.set(self, "failover_ratio", value)
 
 
+if not MYPY:
+    class RegionBackendServiceHaPolicyArgsDict(TypedDict):
+        fast_ip_move: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        Specifies whether fast IP move is enabled, and if so, the mechanism to achieve it.
+        Supported values are:
+        * `DISABLED`: Fast IP Move is disabled. You can only use the haPolicy.leader API to
+        update the leader.
+        * `GARP_RA`: Provides a method to very quickly define a new network endpoint as the
+        leader. This method is faster than updating the leader using the
+        haPolicy.leader API. Fast IP move works as follows: The VM hosting the
+        network endpoint that should become the new leader sends either a
+        Gratuitous ARP (GARP) packet (IPv4) or an ICMPv6 Router Advertisement(RA)
+        packet (IPv6). Google Cloud immediately but temporarily associates the
+        forwarding rule IP address with that VM, and both new and in-flight packets
+        are quickly delivered to that VM.
+        Possible values are: `DISABLED`, `GARP_RA`.
+        """
+        leader: NotRequired[pulumi.Input['RegionBackendServiceHaPolicyLeaderArgsDict']]
+        """
+        Selects one of the network endpoints attached to the backend NEGs of this service as the
+        active endpoint (the leader) that receives all traffic.
+        Structure is documented below.
+        """
+elif False:
+    RegionBackendServiceHaPolicyArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class RegionBackendServiceHaPolicyArgs:
+    def __init__(__self__, *,
+                 fast_ip_move: Optional[pulumi.Input[_builtins.str]] = None,
+                 leader: Optional[pulumi.Input['RegionBackendServiceHaPolicyLeaderArgs']] = None):
+        """
+        :param pulumi.Input[_builtins.str] fast_ip_move: Specifies whether fast IP move is enabled, and if so, the mechanism to achieve it.
+               Supported values are:
+               * `DISABLED`: Fast IP Move is disabled. You can only use the haPolicy.leader API to
+               update the leader.
+               * `GARP_RA`: Provides a method to very quickly define a new network endpoint as the
+               leader. This method is faster than updating the leader using the
+               haPolicy.leader API. Fast IP move works as follows: The VM hosting the
+               network endpoint that should become the new leader sends either a
+               Gratuitous ARP (GARP) packet (IPv4) or an ICMPv6 Router Advertisement(RA)
+               packet (IPv6). Google Cloud immediately but temporarily associates the
+               forwarding rule IP address with that VM, and both new and in-flight packets
+               are quickly delivered to that VM.
+               Possible values are: `DISABLED`, `GARP_RA`.
+        :param pulumi.Input['RegionBackendServiceHaPolicyLeaderArgs'] leader: Selects one of the network endpoints attached to the backend NEGs of this service as the
+               active endpoint (the leader) that receives all traffic.
+               Structure is documented below.
+        """
+        if fast_ip_move is not None:
+            pulumi.set(__self__, "fast_ip_move", fast_ip_move)
+        if leader is not None:
+            pulumi.set(__self__, "leader", leader)
+
+    @_builtins.property
+    @pulumi.getter(name="fastIpMove")
+    def fast_ip_move(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        Specifies whether fast IP move is enabled, and if so, the mechanism to achieve it.
+        Supported values are:
+        * `DISABLED`: Fast IP Move is disabled. You can only use the haPolicy.leader API to
+        update the leader.
+        * `GARP_RA`: Provides a method to very quickly define a new network endpoint as the
+        leader. This method is faster than updating the leader using the
+        haPolicy.leader API. Fast IP move works as follows: The VM hosting the
+        network endpoint that should become the new leader sends either a
+        Gratuitous ARP (GARP) packet (IPv4) or an ICMPv6 Router Advertisement(RA)
+        packet (IPv6). Google Cloud immediately but temporarily associates the
+        forwarding rule IP address with that VM, and both new and in-flight packets
+        are quickly delivered to that VM.
+        Possible values are: `DISABLED`, `GARP_RA`.
+        """
+        return pulumi.get(self, "fast_ip_move")
+
+    @fast_ip_move.setter
+    def fast_ip_move(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "fast_ip_move", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def leader(self) -> Optional[pulumi.Input['RegionBackendServiceHaPolicyLeaderArgs']]:
+        """
+        Selects one of the network endpoints attached to the backend NEGs of this service as the
+        active endpoint (the leader) that receives all traffic.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "leader")
+
+    @leader.setter
+    def leader(self, value: Optional[pulumi.Input['RegionBackendServiceHaPolicyLeaderArgs']]):
+        pulumi.set(self, "leader", value)
+
+
+if not MYPY:
+    class RegionBackendServiceHaPolicyLeaderArgsDict(TypedDict):
+        backend_group: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        A fully-qualified URL of the zonal Network Endpoint Group (NEG) that the leader is
+        attached to.
+        """
+        network_endpoint: NotRequired[pulumi.Input['RegionBackendServiceHaPolicyLeaderNetworkEndpointArgsDict']]
+        """
+        The network endpoint within the leader.backendGroup that is designated as the leader.
+        Structure is documented below.
+        """
+elif False:
+    RegionBackendServiceHaPolicyLeaderArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class RegionBackendServiceHaPolicyLeaderArgs:
+    def __init__(__self__, *,
+                 backend_group: Optional[pulumi.Input[_builtins.str]] = None,
+                 network_endpoint: Optional[pulumi.Input['RegionBackendServiceHaPolicyLeaderNetworkEndpointArgs']] = None):
+        """
+        :param pulumi.Input[_builtins.str] backend_group: A fully-qualified URL of the zonal Network Endpoint Group (NEG) that the leader is
+               attached to.
+        :param pulumi.Input['RegionBackendServiceHaPolicyLeaderNetworkEndpointArgs'] network_endpoint: The network endpoint within the leader.backendGroup that is designated as the leader.
+               Structure is documented below.
+        """
+        if backend_group is not None:
+            pulumi.set(__self__, "backend_group", backend_group)
+        if network_endpoint is not None:
+            pulumi.set(__self__, "network_endpoint", network_endpoint)
+
+    @_builtins.property
+    @pulumi.getter(name="backendGroup")
+    def backend_group(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        A fully-qualified URL of the zonal Network Endpoint Group (NEG) that the leader is
+        attached to.
+        """
+        return pulumi.get(self, "backend_group")
+
+    @backend_group.setter
+    def backend_group(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "backend_group", value)
+
+    @_builtins.property
+    @pulumi.getter(name="networkEndpoint")
+    def network_endpoint(self) -> Optional[pulumi.Input['RegionBackendServiceHaPolicyLeaderNetworkEndpointArgs']]:
+        """
+        The network endpoint within the leader.backendGroup that is designated as the leader.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "network_endpoint")
+
+    @network_endpoint.setter
+    def network_endpoint(self, value: Optional[pulumi.Input['RegionBackendServiceHaPolicyLeaderNetworkEndpointArgs']]):
+        pulumi.set(self, "network_endpoint", value)
+
+
+if not MYPY:
+    class RegionBackendServiceHaPolicyLeaderNetworkEndpointArgsDict(TypedDict):
+        instance: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        The name of the VM instance of the leader network endpoint. The instance must
+        already be attached to the NEG specified in the haPolicy.leader.backendGroup.
+        """
+elif False:
+    RegionBackendServiceHaPolicyLeaderNetworkEndpointArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class RegionBackendServiceHaPolicyLeaderNetworkEndpointArgs:
+    def __init__(__self__, *,
+                 instance: Optional[pulumi.Input[_builtins.str]] = None):
+        """
+        :param pulumi.Input[_builtins.str] instance: The name of the VM instance of the leader network endpoint. The instance must
+               already be attached to the NEG specified in the haPolicy.leader.backendGroup.
+        """
+        if instance is not None:
+            pulumi.set(__self__, "instance", instance)
+
+    @_builtins.property
+    @pulumi.getter
+    def instance(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The name of the VM instance of the leader network endpoint. The instance must
+        already be attached to the NEG specified in the haPolicy.leader.backendGroup.
+        """
+        return pulumi.get(self, "instance")
+
+    @instance.setter
+    def instance(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "instance", value)
+
+
 if not MYPY:
     class RegionBackendServiceIamBindingConditionArgsDict(TypedDict):
         expression: pulumi.Input[_builtins.str]
@@ -49323,6 +49520,164 @@ class RegionResizeRequestStatusLastAttemptErrorErrorErrorDetailQuotaInfoArgs:
         pulumi.set(self, "rollout_status", value)
 
 
+if not MYPY:
+    class RegionSecurityPolicyAdvancedOptionsConfigArgsDict(TypedDict):
+        json_custom_config: NotRequired[pulumi.Input['RegionSecurityPolicyAdvancedOptionsConfigJsonCustomConfigArgsDict']]
+        """
+        Custom configuration to apply the JSON parsing. Only applicable when JSON parsing is set to STANDARD.
+        Structure is documented below.
+        """
+        json_parsing: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        JSON body parsing. Supported values include: "DISABLED", "STANDARD", "STANDARD_WITH_GRAPHQL".
+        Possible values are: `DISABLED`, `STANDARD`, `STANDARD_WITH_GRAPHQL`.
+        """
+        log_level: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        Logging level. Supported values include: "NORMAL", "VERBOSE".
+        Possible values are: `NORMAL`, `VERBOSE`.
+        """
+        request_body_inspection_size: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        The maximum request size chosen by the customer with Waf enabled. Values supported are "8KB", "16KB, "32KB", "48KB" and "64KB".
+        Values are case insensitive.
+        Possible values are: `8KB`, `16KB`, `32KB`, `48KB`, `64KB`.
+        """
+        user_ip_request_headers: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
+        """
+        An optional list of case-insensitive request header names to use for resolving the callers client IP address.
+        """
+elif False:
+    RegionSecurityPolicyAdvancedOptionsConfigArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class RegionSecurityPolicyAdvancedOptionsConfigArgs:
+    def __init__(__self__, *,
+                 json_custom_config: Optional[pulumi.Input['RegionSecurityPolicyAdvancedOptionsConfigJsonCustomConfigArgs']] = None,
+                 json_parsing: Optional[pulumi.Input[_builtins.str]] = None,
+                 log_level: Optional[pulumi.Input[_builtins.str]] = None,
+                 request_body_inspection_size: Optional[pulumi.Input[_builtins.str]] = None,
+                 user_ip_request_headers: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
+        """
+        :param pulumi.Input['RegionSecurityPolicyAdvancedOptionsConfigJsonCustomConfigArgs'] json_custom_config: Custom configuration to apply the JSON parsing. Only applicable when JSON parsing is set to STANDARD.
+               Structure is documented below.
+        :param pulumi.Input[_builtins.str] json_parsing: JSON body parsing. Supported values include: "DISABLED", "STANDARD", "STANDARD_WITH_GRAPHQL".
+               Possible values are: `DISABLED`, `STANDARD`, `STANDARD_WITH_GRAPHQL`.
+        :param pulumi.Input[_builtins.str] log_level: Logging level. Supported values include: "NORMAL", "VERBOSE".
+               Possible values are: `NORMAL`, `VERBOSE`.
+        :param pulumi.Input[_builtins.str] request_body_inspection_size: The maximum request size chosen by the customer with Waf enabled. Values supported are "8KB", "16KB, "32KB", "48KB" and "64KB".
+               Values are case insensitive.
+               Possible values are: `8KB`, `16KB`, `32KB`, `48KB`, `64KB`.
+        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] user_ip_request_headers: An optional list of case-insensitive request header names to use for resolving the callers client IP address.
+        """
+        if json_custom_config is not None:
+            pulumi.set(__self__, "json_custom_config", json_custom_config)
+        if json_parsing is not None:
+            pulumi.set(__self__, "json_parsing", json_parsing)
+        if log_level is not None:
+            pulumi.set(__self__, "log_level", log_level)
+        if request_body_inspection_size is not None:
+            pulumi.set(__self__, "request_body_inspection_size", request_body_inspection_size)
+        if user_ip_request_headers is not None:
+            pulumi.set(__self__, "user_ip_request_headers", user_ip_request_headers)
+
+    @_builtins.property
+    @pulumi.getter(name="jsonCustomConfig")
+    def json_custom_config(self) -> Optional[pulumi.Input['RegionSecurityPolicyAdvancedOptionsConfigJsonCustomConfigArgs']]:
+        """
+        Custom configuration to apply the JSON parsing. Only applicable when JSON parsing is set to STANDARD.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "json_custom_config")
+
+    @json_custom_config.setter
+    def json_custom_config(self, value: Optional[pulumi.Input['RegionSecurityPolicyAdvancedOptionsConfigJsonCustomConfigArgs']]):
+        pulumi.set(self, "json_custom_config", value)
+
+    @_builtins.property
+    @pulumi.getter(name="jsonParsing")
+    def json_parsing(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        JSON body parsing. Supported values include: "DISABLED", "STANDARD", "STANDARD_WITH_GRAPHQL".
+        Possible values are: `DISABLED`, `STANDARD`, `STANDARD_WITH_GRAPHQL`.
+        """
+        return pulumi.get(self, "json_parsing")
+
+    @json_parsing.setter
+    def json_parsing(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "json_parsing", value)
+
+    @_builtins.property
+    @pulumi.getter(name="logLevel")
+    def log_level(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        Logging level. Supported values include: "NORMAL", "VERBOSE".
+        Possible values are: `NORMAL`, `VERBOSE`.
+        """
+        return pulumi.get(self, "log_level")
+
+    @log_level.setter
+    def log_level(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "log_level", value)
+
+    @_builtins.property
+    @pulumi.getter(name="requestBodyInspectionSize")
+    def request_body_inspection_size(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The maximum request size chosen by the customer with Waf enabled. Values supported are "8KB", "16KB, "32KB", "48KB" and "64KB".
+        Values are case insensitive.
+        Possible values are: `8KB`, `16KB`, `32KB`, `48KB`, `64KB`.
+        """
+        return pulumi.get(self, "request_body_inspection_size")
+
+    @request_body_inspection_size.setter
+    def request_body_inspection_size(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "request_body_inspection_size", value)
+
+    @_builtins.property
+    @pulumi.getter(name="userIpRequestHeaders")
+    def user_ip_request_headers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
+        """
+        An optional list of case-insensitive request header names to use for resolving the callers client IP address.
+        """
+        return pulumi.get(self, "user_ip_request_headers")
+
+    @user_ip_request_headers.setter
+    def user_ip_request_headers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
+        pulumi.set(self, "user_ip_request_headers", value)
+
+
+if not MYPY:
+    class RegionSecurityPolicyAdvancedOptionsConfigJsonCustomConfigArgsDict(TypedDict):
+        content_types: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]
+        """
+        A list of custom Content-Type header values to apply the JSON parsing.
+        """
+elif False:
+    RegionSecurityPolicyAdvancedOptionsConfigJsonCustomConfigArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class RegionSecurityPolicyAdvancedOptionsConfigJsonCustomConfigArgs:
+    def __init__(__self__, *,
+                 content_types: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]):
+        """
+        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] content_types: A list of custom Content-Type header values to apply the JSON parsing.
+        """
+        pulumi.set(__self__, "content_types", content_types)
+
+    @_builtins.property
+    @pulumi.getter(name="contentTypes")
+    def content_types(self) -> pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]:
+        """
+        A list of custom Content-Type header values to apply the JSON parsing.
+        """
+        return pulumi.get(self, "content_types")
+
+    @content_types.setter
+    def content_types(self, value: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]):
+        pulumi.set(self, "content_types", value)
+
+
 if not MYPY:
     class RegionSecurityPolicyDdosProtectionConfigArgsDict(TypedDict):
         ddos_protection: pulumi.Input[_builtins.str]

pulumi_gcp/compute/get_region_backend_service.py

@@ -27,7 +27,7 @@ class GetRegionBackendServiceResult:
     """
     A collection of values returned by getRegionBackendService.
     """
-    def __init__(__self__, affinity_cookie_ttl_sec=None, backends=None, cdn_policies=None, circuit_breakers=None, connection_draining_timeout_sec=None, connection_tracking_policies=None, consistent_hashes=None, creation_timestamp=None, custom_metrics=None, description=None, dynamic_forwardings=None, enable_cdn=None, failover_policies=None, fingerprint=None, generated_id=None, health_checks=None, iaps=None, id=None, ip_address_selection_policy=None, load_balancing_scheme=None, locality_lb_policy=None, log_configs=None, name=None, network=None, outlier_detections=None, port_name=None, project=None, protocol=None, region=None, security_policy=None, self_link=None, session_affinity=None, strong_session_affinity_cookies=None, subsettings=None, timeout_sec=None):
+    def __init__(__self__, affinity_cookie_ttl_sec=None, backends=None, cdn_policies=None, circuit_breakers=None, connection_draining_timeout_sec=None, connection_tracking_policies=None, consistent_hashes=None, creation_timestamp=None, custom_metrics=None, description=None, dynamic_forwardings=None, enable_cdn=None, failover_policies=None, fingerprint=None, generated_id=None, ha_policies=None, health_checks=None, iaps=None, id=None, ip_address_selection_policy=None, load_balancing_scheme=None, locality_lb_policy=None, log_configs=None, name=None, network=None, outlier_detections=None, port_name=None, project=None, protocol=None, region=None, security_policy=None, self_link=None, session_affinity=None, strong_session_affinity_cookies=None, subsettings=None, timeout_sec=None):
         if affinity_cookie_ttl_sec and not isinstance(affinity_cookie_ttl_sec, int):
             raise TypeError("Expected argument 'affinity_cookie_ttl_sec' to be a int")
         pulumi.set(__self__, "affinity_cookie_ttl_sec", affinity_cookie_ttl_sec)
@@ -73,6 +73,9 @@ class GetRegionBackendServiceResult:
         if generated_id and not isinstance(generated_id, int):
             raise TypeError("Expected argument 'generated_id' to be a int")
         pulumi.set(__self__, "generated_id", generated_id)
+        if ha_policies and not isinstance(ha_policies, list):
+            raise TypeError("Expected argument 'ha_policies' to be a list")
+        pulumi.set(__self__, "ha_policies", ha_policies)
         if health_checks and not isinstance(health_checks, list):
             raise TypeError("Expected argument 'health_checks' to be a list")
         pulumi.set(__self__, "health_checks", health_checks)
@@ -209,6 +212,11 @@ class GetRegionBackendServiceResult:
     def generated_id(self) -> _builtins.int:
         return pulumi.get(self, "generated_id")
 
+    @_builtins.property
+    @pulumi.getter(name="haPolicies")
+    def ha_policies(self) -> Sequence['outputs.GetRegionBackendServiceHaPolicyResult']:
+        return pulumi.get(self, "ha_policies")
+
     @_builtins.property
     @pulumi.getter(name="healthChecks")
     def health_checks(self) -> Sequence[_builtins.str]:
@@ -334,6 +342,7 @@ class AwaitableGetRegionBackendServiceResult(GetRegionBackendServiceResult):
             failover_policies=self.failover_policies,
             fingerprint=self.fingerprint,
             generated_id=self.generated_id,
+            ha_policies=self.ha_policies,
             health_checks=self.health_checks,
             iaps=self.iaps,
             id=self.id,
@@ -404,6 +413,7 @@ def get_region_backend_service(name: Optional[_builtins.str] = None,
         failover_policies=pulumi.get(__ret__, 'failover_policies'),
         fingerprint=pulumi.get(__ret__, 'fingerprint'),
         generated_id=pulumi.get(__ret__, 'generated_id'),
+        ha_policies=pulumi.get(__ret__, 'ha_policies'),
         health_checks=pulumi.get(__ret__, 'health_checks'),
         iaps=pulumi.get(__ret__, 'iaps'),
         id=pulumi.get(__ret__, 'id'),
@@ -471,6 +481,7 @@ def get_region_backend_service_output(name: Optional[pulumi.Input[_builtins.str]
         failover_policies=pulumi.get(__response__, 'failover_policies'),
         fingerprint=pulumi.get(__response__, 'fingerprint'),
         generated_id=pulumi.get(__response__, 'generated_id'),
+        ha_policies=pulumi.get(__response__, 'ha_policies'),
         health_checks=pulumi.get(__response__, 'health_checks'),
         iaps=pulumi.get(__response__, 'iaps'),
         id=pulumi.get(__response__, 'id'),