pulumi-gcp 8.28.0a1745598508__py3-none-any.whl → 8.29.0a1746076904__py3-none-any.whl

pulumi_gcp/compute/backend_service.py

@@ -42,6 +42,7 @@ class BackendServiceArgs:
                  locality_lb_policies: Optional[pulumi.Input[Sequence[pulumi.Input['BackendServiceLocalityLbPolicyArgs']]]] = None,
                  locality_lb_policy: Optional[pulumi.Input[builtins.str]] = None,
                  log_config: Optional[pulumi.Input['BackendServiceLogConfigArgs']] = None,
+                 max_stream_duration: Optional[pulumi.Input['BackendServiceMaxStreamDurationArgs']] = None,
                  name: Optional[pulumi.Input[builtins.str]] = None,
                  outlier_detection: Optional[pulumi.Input['BackendServiceOutlierDetectionArgs']] = None,
                  port_name: Optional[pulumi.Input[builtins.str]] = None,
@@ -169,6 +170,13 @@ class BackendServiceArgs:
         :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.
+        :param pulumi.Input['BackendServiceMaxStreamDurationArgs'] max_stream_duration: Specifies the default maximum duration (timeout) for streams to this service. Duration is computed from the
+               beginning of the stream until the response has been completely processed, including all retries. A stream that
+               does not complete in this duration is closed.
+               If not specified, there will be no timeout limit, i.e. the maximum duration is infinite.
+               This value can be overridden in the PathMatcher configuration of the UrlMap that references this backend service.
+               This field is only allowed when the loadBalancingScheme of the backend service is INTERNAL_SELF_MANAGED.
+               Structure is documented below.
         :param pulumi.Input[builtins.str] name: Name of the resource. Provided by the client when the resource is
                created. The name must be 1-63 characters long, and comply with
                RFC1035. Specifically, the name must be 1-63 characters long and match
@@ -254,6 +262,8 @@ class BackendServiceArgs:
             pulumi.set(__self__, "locality_lb_policy", locality_lb_policy)
         if log_config is not None:
             pulumi.set(__self__, "log_config", log_config)
+        if max_stream_duration is not None:
+            pulumi.set(__self__, "max_stream_duration", max_stream_duration)
         if name is not None:
             pulumi.set(__self__, "name", name)
         if outlier_detection is not None:
@@ -612,6 +622,24 @@ class BackendServiceArgs:
     def log_config(self, value: Optional[pulumi.Input['BackendServiceLogConfigArgs']]):
         pulumi.set(self, "log_config", value)
 
+    @property
+    @pulumi.getter(name="maxStreamDuration")
+    def max_stream_duration(self) -> Optional[pulumi.Input['BackendServiceMaxStreamDurationArgs']]:
+        """
+        Specifies the default maximum duration (timeout) for streams to this service. Duration is computed from the
+        beginning of the stream until the response has been completely processed, including all retries. A stream that
+        does not complete in this duration is closed.
+        If not specified, there will be no timeout limit, i.e. the maximum duration is infinite.
+        This value can be overridden in the PathMatcher configuration of the UrlMap that references this backend service.
+        This field is only allowed when the loadBalancingScheme of the backend service is INTERNAL_SELF_MANAGED.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "max_stream_duration")
+
+    @max_stream_duration.setter
+    def max_stream_duration(self, value: Optional[pulumi.Input['BackendServiceMaxStreamDurationArgs']]):
+        pulumi.set(self, "max_stream_duration", value)
+
     @property
     @pulumi.getter
     def name(self) -> Optional[pulumi.Input[builtins.str]]:
@@ -815,6 +843,7 @@ class _BackendServiceState:
                  locality_lb_policies: Optional[pulumi.Input[Sequence[pulumi.Input['BackendServiceLocalityLbPolicyArgs']]]] = None,
                  locality_lb_policy: Optional[pulumi.Input[builtins.str]] = None,
                  log_config: Optional[pulumi.Input['BackendServiceLogConfigArgs']] = None,
+                 max_stream_duration: Optional[pulumi.Input['BackendServiceMaxStreamDurationArgs']] = None,
                  name: Optional[pulumi.Input[builtins.str]] = None,
                  outlier_detection: Optional[pulumi.Input['BackendServiceOutlierDetectionArgs']] = None,
                  port_name: Optional[pulumi.Input[builtins.str]] = None,
@@ -947,6 +976,13 @@ class _BackendServiceState:
         :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.
+        :param pulumi.Input['BackendServiceMaxStreamDurationArgs'] max_stream_duration: Specifies the default maximum duration (timeout) for streams to this service. Duration is computed from the
+               beginning of the stream until the response has been completely processed, including all retries. A stream that
+               does not complete in this duration is closed.
+               If not specified, there will be no timeout limit, i.e. the maximum duration is infinite.
+               This value can be overridden in the PathMatcher configuration of the UrlMap that references this backend service.
+               This field is only allowed when the loadBalancingScheme of the backend service is INTERNAL_SELF_MANAGED.
+               Structure is documented below.
         :param pulumi.Input[builtins.str] name: Name of the resource. Provided by the client when the resource is
                created. The name must be 1-63 characters long, and comply with
                RFC1035. Specifically, the name must be 1-63 characters long and match
@@ -1039,6 +1075,8 @@ class _BackendServiceState:
             pulumi.set(__self__, "locality_lb_policy", locality_lb_policy)
         if log_config is not None:
             pulumi.set(__self__, "log_config", log_config)
+        if max_stream_duration is not None:
+            pulumi.set(__self__, "max_stream_duration", max_stream_duration)
         if name is not None:
             pulumi.set(__self__, "name", name)
         if outlier_detection is not None:
@@ -1436,6 +1474,24 @@ class _BackendServiceState:
     def log_config(self, value: Optional[pulumi.Input['BackendServiceLogConfigArgs']]):
         pulumi.set(self, "log_config", value)
 
+    @property
+    @pulumi.getter(name="maxStreamDuration")
+    def max_stream_duration(self) -> Optional[pulumi.Input['BackendServiceMaxStreamDurationArgs']]:
+        """
+        Specifies the default maximum duration (timeout) for streams to this service. Duration is computed from the
+        beginning of the stream until the response has been completely processed, including all retries. A stream that
+        does not complete in this duration is closed.
+        If not specified, there will be no timeout limit, i.e. the maximum duration is infinite.
+        This value can be overridden in the PathMatcher configuration of the UrlMap that references this backend service.
+        This field is only allowed when the loadBalancingScheme of the backend service is INTERNAL_SELF_MANAGED.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "max_stream_duration")
+
+    @max_stream_duration.setter
+    def max_stream_duration(self, value: Optional[pulumi.Input['BackendServiceMaxStreamDurationArgs']]):
+        pulumi.set(self, "max_stream_duration", value)
+
     @property
     @pulumi.getter
     def name(self) -> Optional[pulumi.Input[builtins.str]]:
@@ -1650,6 +1706,7 @@ class BackendService(pulumi.CustomResource):
                  locality_lb_policies: Optional[pulumi.Input[Sequence[pulumi.Input[Union['BackendServiceLocalityLbPolicyArgs', 'BackendServiceLocalityLbPolicyArgsDict']]]]] = None,
                  locality_lb_policy: Optional[pulumi.Input[builtins.str]] = None,
                  log_config: Optional[pulumi.Input[Union['BackendServiceLogConfigArgs', 'BackendServiceLogConfigArgsDict']]] = None,
+                 max_stream_duration: Optional[pulumi.Input[Union['BackendServiceMaxStreamDurationArgs', 'BackendServiceMaxStreamDurationArgsDict']]] = None,
                  name: Optional[pulumi.Input[builtins.str]] = None,
                  outlier_detection: Optional[pulumi.Input[Union['BackendServiceOutlierDetectionArgs', 'BackendServiceOutlierDetectionArgsDict']]] = None,
                  port_name: Optional[pulumi.Input[builtins.str]] = None,
@@ -2185,6 +2242,13 @@ class BackendService(pulumi.CustomResource):
         :param pulumi.Input[Union['BackendServiceLogConfigArgs', 'BackendServiceLogConfigArgsDict']] 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.
+        :param pulumi.Input[Union['BackendServiceMaxStreamDurationArgs', 'BackendServiceMaxStreamDurationArgsDict']] max_stream_duration: Specifies the default maximum duration (timeout) for streams to this service. Duration is computed from the
+               beginning of the stream until the response has been completely processed, including all retries. A stream that
+               does not complete in this duration is closed.
+               If not specified, there will be no timeout limit, i.e. the maximum duration is infinite.
+               This value can be overridden in the PathMatcher configuration of the UrlMap that references this backend service.
+               This field is only allowed when the loadBalancingScheme of the backend service is INTERNAL_SELF_MANAGED.
+               Structure is documented below.
         :param pulumi.Input[builtins.str] name: Name of the resource. Provided by the client when the resource is
                created. The name must be 1-63 characters long, and comply with
                RFC1035. Specifically, the name must be 1-63 characters long and match
@@ -2678,6 +2742,7 @@ class BackendService(pulumi.CustomResource):
                  locality_lb_policies: Optional[pulumi.Input[Sequence[pulumi.Input[Union['BackendServiceLocalityLbPolicyArgs', 'BackendServiceLocalityLbPolicyArgsDict']]]]] = None,
                  locality_lb_policy: Optional[pulumi.Input[builtins.str]] = None,
                  log_config: Optional[pulumi.Input[Union['BackendServiceLogConfigArgs', 'BackendServiceLogConfigArgsDict']]] = None,
+                 max_stream_duration: Optional[pulumi.Input[Union['BackendServiceMaxStreamDurationArgs', 'BackendServiceMaxStreamDurationArgsDict']]] = None,
                  name: Optional[pulumi.Input[builtins.str]] = None,
                  outlier_detection: Optional[pulumi.Input[Union['BackendServiceOutlierDetectionArgs', 'BackendServiceOutlierDetectionArgsDict']]] = None,
                  port_name: Optional[pulumi.Input[builtins.str]] = None,
@@ -2719,6 +2784,7 @@ class BackendService(pulumi.CustomResource):
             __props__.__dict__["locality_lb_policies"] = locality_lb_policies
             __props__.__dict__["locality_lb_policy"] = locality_lb_policy
             __props__.__dict__["log_config"] = log_config
+            __props__.__dict__["max_stream_duration"] = max_stream_duration
             __props__.__dict__["name"] = name
             __props__.__dict__["outlier_detection"] = outlier_detection
             __props__.__dict__["port_name"] = port_name
@@ -2768,6 +2834,7 @@ class BackendService(pulumi.CustomResource):
             locality_lb_policies: Optional[pulumi.Input[Sequence[pulumi.Input[Union['BackendServiceLocalityLbPolicyArgs', 'BackendServiceLocalityLbPolicyArgsDict']]]]] = None,
             locality_lb_policy: Optional[pulumi.Input[builtins.str]] = None,
             log_config: Optional[pulumi.Input[Union['BackendServiceLogConfigArgs', 'BackendServiceLogConfigArgsDict']]] = None,
+            max_stream_duration: Optional[pulumi.Input[Union['BackendServiceMaxStreamDurationArgs', 'BackendServiceMaxStreamDurationArgsDict']]] = None,
             name: Optional[pulumi.Input[builtins.str]] = None,
             outlier_detection: Optional[pulumi.Input[Union['BackendServiceOutlierDetectionArgs', 'BackendServiceOutlierDetectionArgsDict']]] = None,
             port_name: Optional[pulumi.Input[builtins.str]] = None,
@@ -2905,6 +2972,13 @@ class BackendService(pulumi.CustomResource):
         :param pulumi.Input[Union['BackendServiceLogConfigArgs', 'BackendServiceLogConfigArgsDict']] 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.
+        :param pulumi.Input[Union['BackendServiceMaxStreamDurationArgs', 'BackendServiceMaxStreamDurationArgsDict']] max_stream_duration: Specifies the default maximum duration (timeout) for streams to this service. Duration is computed from the
+               beginning of the stream until the response has been completely processed, including all retries. A stream that
+               does not complete in this duration is closed.
+               If not specified, there will be no timeout limit, i.e. the maximum duration is infinite.
+               This value can be overridden in the PathMatcher configuration of the UrlMap that references this backend service.
+               This field is only allowed when the loadBalancingScheme of the backend service is INTERNAL_SELF_MANAGED.
+               Structure is documented below.
         :param pulumi.Input[builtins.str] name: Name of the resource. Provided by the client when the resource is
                created. The name must be 1-63 characters long, and comply with
                RFC1035. Specifically, the name must be 1-63 characters long and match
@@ -2978,6 +3052,7 @@ class BackendService(pulumi.CustomResource):
         __props__.__dict__["locality_lb_policies"] = locality_lb_policies
         __props__.__dict__["locality_lb_policy"] = locality_lb_policy
         __props__.__dict__["log_config"] = log_config
+        __props__.__dict__["max_stream_duration"] = max_stream_duration
         __props__.__dict__["name"] = name
         __props__.__dict__["outlier_detection"] = outlier_detection
         __props__.__dict__["port_name"] = port_name
@@ -3271,6 +3346,20 @@ class BackendService(pulumi.CustomResource):
         """
         return pulumi.get(self, "log_config")
 
+    @property
+    @pulumi.getter(name="maxStreamDuration")
+    def max_stream_duration(self) -> pulumi.Output[Optional['outputs.BackendServiceMaxStreamDuration']]:
+        """
+        Specifies the default maximum duration (timeout) for streams to this service. Duration is computed from the
+        beginning of the stream until the response has been completely processed, including all retries. A stream that
+        does not complete in this duration is closed.
+        If not specified, there will be no timeout limit, i.e. the maximum duration is infinite.
+        This value can be overridden in the PathMatcher configuration of the UrlMap that references this backend service.
+        This field is only allowed when the loadBalancingScheme of the backend service is INTERNAL_SELF_MANAGED.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "max_stream_duration")
+
     @property
     @pulumi.getter
     def name(self) -> pulumi.Output[builtins.str]:

pulumi_gcp/compute/firewall_policy_with_rules.py

@@ -338,7 +338,7 @@ class FirewallPolicyWithRules(pulumi.CustomResource):
                     "enable_logging": True,
                     "action": "allow",
                     "direction": "EGRESS",
-                    "target_resources": [f"https://www.googleapis.com/compute/beta/projects/{project.name}/global/networks/default"],
+                    "target_resources": [f"https://www.googleapis.com/compute/beta/projects/{project.project_id}/global/networks/default"],
                     "match": {
                         "dest_ip_ranges": ["11.100.0.1/32"],
                         "dest_fqdns": [
@@ -519,7 +519,7 @@ class FirewallPolicyWithRules(pulumi.CustomResource):
                     "enable_logging": True,
                     "action": "allow",
                     "direction": "EGRESS",
-                    "target_resources": [f"https://www.googleapis.com/compute/beta/projects/{project.name}/global/networks/default"],
+                    "target_resources": [f"https://www.googleapis.com/compute/beta/projects/{project.project_id}/global/networks/default"],
                     "match": {
                         "dest_ip_ranges": ["11.100.0.1/32"],
                         "dest_fqdns": [

pulumi_gcp/compute/get_backend_service.py

@@ -28,7 +28,7 @@ class GetBackendServiceResult:
     """
     A collection of values returned by getBackendService.
     """
-    def __init__(__self__, affinity_cookie_ttl_sec=None, backends=None, cdn_policies=None, circuit_breakers=None, compression_mode=None, connection_draining_timeout_sec=None, consistent_hash=None, creation_timestamp=None, custom_metrics=None, custom_request_headers=None, custom_response_headers=None, description=None, edge_security_policy=None, enable_cdn=None, fingerprint=None, generated_id=None, health_checks=None, iaps=None, id=None, ip_address_selection_policy=None, load_balancing_scheme=None, locality_lb_policies=None, locality_lb_policy=None, log_configs=None, name=None, outlier_detections=None, port_name=None, project=None, protocol=None, security_policy=None, security_settings=None, self_link=None, service_lb_policy=None, session_affinity=None, strong_session_affinity_cookies=None, timeout_sec=None, tls_settings=None):
+    def __init__(__self__, affinity_cookie_ttl_sec=None, backends=None, cdn_policies=None, circuit_breakers=None, compression_mode=None, connection_draining_timeout_sec=None, consistent_hash=None, creation_timestamp=None, custom_metrics=None, custom_request_headers=None, custom_response_headers=None, description=None, edge_security_policy=None, enable_cdn=None, fingerprint=None, generated_id=None, health_checks=None, iaps=None, id=None, ip_address_selection_policy=None, load_balancing_scheme=None, locality_lb_policies=None, locality_lb_policy=None, log_configs=None, max_stream_durations=None, name=None, outlier_detections=None, port_name=None, project=None, protocol=None, security_policy=None, security_settings=None, self_link=None, service_lb_policy=None, session_affinity=None, strong_session_affinity_cookies=None, timeout_sec=None, tls_settings=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)
@@ -101,6 +101,9 @@ class GetBackendServiceResult:
         if log_configs and not isinstance(log_configs, list):
             raise TypeError("Expected argument 'log_configs' to be a list")
         pulumi.set(__self__, "log_configs", log_configs)
+        if max_stream_durations and not isinstance(max_stream_durations, list):
+            raise TypeError("Expected argument 'max_stream_durations' to be a list")
+        pulumi.set(__self__, "max_stream_durations", max_stream_durations)
         if name and not isinstance(name, str):
             raise TypeError("Expected argument 'name' to be a str")
         pulumi.set(__self__, "name", name)
@@ -285,6 +288,11 @@ class GetBackendServiceResult:
     def log_configs(self) -> Sequence['outputs.GetBackendServiceLogConfigResult']:
         return pulumi.get(self, "log_configs")
 
+    @property
+    @pulumi.getter(name="maxStreamDurations")
+    def max_stream_durations(self) -> Sequence['outputs.GetBackendServiceMaxStreamDurationResult']:
+        return pulumi.get(self, "max_stream_durations")
+
     @property
     @pulumi.getter
     def name(self) -> builtins.str:
@@ -396,6 +404,7 @@ class AwaitableGetBackendServiceResult(GetBackendServiceResult):
             locality_lb_policies=self.locality_lb_policies,
             locality_lb_policy=self.locality_lb_policy,
             log_configs=self.log_configs,
+            max_stream_durations=self.max_stream_durations,
             name=self.name,
             outlier_detections=self.outlier_detections,
             port_name=self.port_name,
@@ -468,6 +477,7 @@ def get_backend_service(name: Optional[builtins.str] = None,
         locality_lb_policies=pulumi.get(__ret__, 'locality_lb_policies'),
         locality_lb_policy=pulumi.get(__ret__, 'locality_lb_policy'),
         log_configs=pulumi.get(__ret__, 'log_configs'),
+        max_stream_durations=pulumi.get(__ret__, 'max_stream_durations'),
         name=pulumi.get(__ret__, 'name'),
         outlier_detections=pulumi.get(__ret__, 'outlier_detections'),
         port_name=pulumi.get(__ret__, 'port_name'),
@@ -537,6 +547,7 @@ def get_backend_service_output(name: Optional[pulumi.Input[builtins.str]] = None
         locality_lb_policies=pulumi.get(__response__, 'locality_lb_policies'),
         locality_lb_policy=pulumi.get(__response__, 'locality_lb_policy'),
         log_configs=pulumi.get(__response__, 'log_configs'),
+        max_stream_durations=pulumi.get(__response__, 'max_stream_durations'),
         name=pulumi.get(__response__, 'name'),
         outlier_detections=pulumi.get(__response__, 'outlier_detections'),
         port_name=pulumi.get(__response__, 'port_name'),

pulumi_gcp/compute/get_storage_pool_iam_policy.py

@@ -0,0 +1,183 @@
+# coding=utf-8
+# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
+# *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+import builtins
+import copy
+import warnings
+import sys
+import pulumi
+import pulumi.runtime
+from typing import Any, Mapping, Optional, Sequence, Union, overload
+if sys.version_info >= (3, 11):
+    from typing import NotRequired, TypedDict, TypeAlias
+else:
+    from typing_extensions import NotRequired, TypedDict, TypeAlias
+from .. import _utilities
+
+__all__ = [
+    'GetStoragePoolIamPolicyResult',
+    'AwaitableGetStoragePoolIamPolicyResult',
+    'get_storage_pool_iam_policy',
+    'get_storage_pool_iam_policy_output',
+]
+
+@pulumi.output_type
+class GetStoragePoolIamPolicyResult:
+    """
+    A collection of values returned by getStoragePoolIamPolicy.
+    """
+    def __init__(__self__, etag=None, id=None, name=None, policy_data=None, project=None, zone=None):
+        if etag and not isinstance(etag, str):
+            raise TypeError("Expected argument 'etag' to be a str")
+        pulumi.set(__self__, "etag", etag)
+        if id and not isinstance(id, str):
+            raise TypeError("Expected argument 'id' to be a str")
+        pulumi.set(__self__, "id", id)
+        if name and not isinstance(name, str):
+            raise TypeError("Expected argument 'name' to be a str")
+        pulumi.set(__self__, "name", name)
+        if policy_data and not isinstance(policy_data, str):
+            raise TypeError("Expected argument 'policy_data' to be a str")
+        pulumi.set(__self__, "policy_data", policy_data)
+        if project and not isinstance(project, str):
+            raise TypeError("Expected argument 'project' to be a str")
+        pulumi.set(__self__, "project", project)
+        if zone and not isinstance(zone, str):
+            raise TypeError("Expected argument 'zone' to be a str")
+        pulumi.set(__self__, "zone", zone)
+
+    @property
+    @pulumi.getter
+    def etag(self) -> builtins.str:
+        """
+        (Computed) The etag of the IAM policy.
+        """
+        return pulumi.get(self, "etag")
+
+    @property
+    @pulumi.getter
+    def id(self) -> builtins.str:
+        """
+        The provider-assigned unique ID for this managed resource.
+        """
+        return pulumi.get(self, "id")
+
+    @property
+    @pulumi.getter
+    def name(self) -> builtins.str:
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter(name="policyData")
+    def policy_data(self) -> builtins.str:
+        """
+        (Required only by `compute.StoragePoolIamPolicy`) The policy data generated by
+        a `organizations_get_iam_policy` data source.
+        """
+        return pulumi.get(self, "policy_data")
+
+    @property
+    @pulumi.getter
+    def project(self) -> builtins.str:
+        return pulumi.get(self, "project")
+
+    @property
+    @pulumi.getter
+    def zone(self) -> builtins.str:
+        return pulumi.get(self, "zone")
+
+
+class AwaitableGetStoragePoolIamPolicyResult(GetStoragePoolIamPolicyResult):
+    # pylint: disable=using-constant-test
+    def __await__(self):
+        if False:
+            yield self
+        return GetStoragePoolIamPolicyResult(
+            etag=self.etag,
+            id=self.id,
+            name=self.name,
+            policy_data=self.policy_data,
+            project=self.project,
+            zone=self.zone)
+
+
+def get_storage_pool_iam_policy(name: Optional[builtins.str] = None,
+                                project: Optional[builtins.str] = None,
+                                zone: Optional[builtins.str] = None,
+                                opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetStoragePoolIamPolicyResult:
+    """
+    Retrieves the current IAM policy data for storagepool
+
+    ## Example Usage
+
+    ```python
+    import pulumi
+    import pulumi_gcp as gcp
+
+    policy = gcp.compute.get_storage_pool_iam_policy(project=test_storage_pool_basic["project"],
+        zone=test_storage_pool_basic["zone"],
+        name=test_storage_pool_basic["name"])
+    ```
+
+
+    :param builtins.str name: Used to find the parent resource to bind the IAM policy to
+    :param builtins.str project: The ID of the project in which the resource belongs.
+           If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.
+    :param builtins.str zone: A reference to the zone where the storage pool resides. Used to find the parent resource to bind the IAM policy to. If not specified,
+           the value will be parsed from the identifier of the parent resource. If no zone is provided in the parent identifier and no
+           zone is specified, it is taken from the provider configuration.
+    """
+    __args__ = dict()
+    __args__['name'] = name
+    __args__['project'] = project
+    __args__['zone'] = zone
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke('gcp:compute/getStoragePoolIamPolicy:getStoragePoolIamPolicy', __args__, opts=opts, typ=GetStoragePoolIamPolicyResult).value
+
+    return AwaitableGetStoragePoolIamPolicyResult(
+        etag=pulumi.get(__ret__, 'etag'),
+        id=pulumi.get(__ret__, 'id'),
+        name=pulumi.get(__ret__, 'name'),
+        policy_data=pulumi.get(__ret__, 'policy_data'),
+        project=pulumi.get(__ret__, 'project'),
+        zone=pulumi.get(__ret__, 'zone'))
+def get_storage_pool_iam_policy_output(name: Optional[pulumi.Input[builtins.str]] = None,
+                                       project: Optional[pulumi.Input[Optional[builtins.str]]] = None,
+                                       zone: Optional[pulumi.Input[Optional[builtins.str]]] = None,
+                                       opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetStoragePoolIamPolicyResult]:
+    """
+    Retrieves the current IAM policy data for storagepool
+
+    ## Example Usage
+
+    ```python
+    import pulumi
+    import pulumi_gcp as gcp
+
+    policy = gcp.compute.get_storage_pool_iam_policy(project=test_storage_pool_basic["project"],
+        zone=test_storage_pool_basic["zone"],
+        name=test_storage_pool_basic["name"])
+    ```
+
+
+    :param builtins.str name: Used to find the parent resource to bind the IAM policy to
+    :param builtins.str project: The ID of the project in which the resource belongs.
+           If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.
+    :param builtins.str zone: A reference to the zone where the storage pool resides. Used to find the parent resource to bind the IAM policy to. If not specified,
+           the value will be parsed from the identifier of the parent resource. If no zone is provided in the parent identifier and no
+           zone is specified, it is taken from the provider configuration.
+    """
+    __args__ = dict()
+    __args__['name'] = name
+    __args__['project'] = project
+    __args__['zone'] = zone
+    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke_output('gcp:compute/getStoragePoolIamPolicy:getStoragePoolIamPolicy', __args__, opts=opts, typ=GetStoragePoolIamPolicyResult)
+    return __ret__.apply(lambda __response__: GetStoragePoolIamPolicyResult(
+        etag=pulumi.get(__response__, 'etag'),
+        id=pulumi.get(__response__, 'id'),
+        name=pulumi.get(__response__, 'name'),
+        policy_data=pulumi.get(__response__, 'policy_data'),
+        project=pulumi.get(__response__, 'project'),
+        zone=pulumi.get(__response__, 'zone')))