pulumi-gcp 7.29.0a1719364094__py3-none-any.whl → 7.29.0a1719416802__py3-none-any.whl

pulumi_gcp/compute/outputs.py

@@ -440,6 +440,8 @@ __all__ = [
     'SecurityPolicyRuleMatch',
     'SecurityPolicyRuleMatchConfig',
     'SecurityPolicyRuleMatchExpr',
+    'SecurityPolicyRuleMatchExprOptions',
+    'SecurityPolicyRuleMatchExprOptionsRecaptchaOptions',
     'SecurityPolicyRulePreconfiguredWafConfig',
     'SecurityPolicyRulePreconfiguredWafConfigExclusion',
     'SecurityPolicyRulePreconfiguredWafConfigExclusionRequestCooky',
@@ -728,6 +730,8 @@ __all__ = [
     'GetSecurityPolicyRuleMatchResult',
     'GetSecurityPolicyRuleMatchConfigResult',
     'GetSecurityPolicyRuleMatchExprResult',
+    'GetSecurityPolicyRuleMatchExprOptionResult',
+    'GetSecurityPolicyRuleMatchExprOptionRecaptchaOptionResult',
     'GetSecurityPolicyRulePreconfiguredWafConfigResult',
     'GetSecurityPolicyRulePreconfiguredWafConfigExclusionResult',
     'GetSecurityPolicyRulePreconfiguredWafConfigExclusionRequestCookyResult',
@@ -31881,7 +31885,9 @@ class SecurityPolicyRuleMatch(dict):
     @staticmethod
     def __key_warning(key: str):
         suggest = None
-        if key == "versionedExpr":
+        if key == "exprOptions":
+            suggest = "expr_options"
+        elif key == "versionedExpr":
             suggest = "versioned_expr"
 
         if suggest:
@@ -31898,6 +31904,7 @@ class SecurityPolicyRuleMatch(dict):
     def __init__(__self__, *,
                  config: Optional['outputs.SecurityPolicyRuleMatchConfig'] = None,
                  expr: Optional['outputs.SecurityPolicyRuleMatchExpr'] = None,
+                 expr_options: Optional['outputs.SecurityPolicyRuleMatchExprOptions'] = None,
                  versioned_expr: Optional[str] = None):
         """
         :param 'SecurityPolicyRuleMatchConfigArgs' config: The configuration options available when specifying versionedExpr.
@@ -31905,6 +31912,8 @@ class SecurityPolicyRuleMatch(dict):
                Structure is documented below.
         :param 'SecurityPolicyRuleMatchExprArgs' expr: User defined CEVAL expression. A CEVAL expression is used to specify match criteria such as origin.ip, source.region_code and contents in the request header.
                Structure is documented below.
+        :param 'SecurityPolicyRuleMatchExprOptionsArgs' expr_options: The configuration options available when specifying a user defined CEVAL expression (i.e., 'expr').
+               Structure is documented below.
         :param str versioned_expr: Preconfigured versioned expression. If this field is specified, config must also be specified.
                Available preconfigured expressions along with their requirements are: SRC_IPS_V1 - must specify the corresponding srcIpRange field in config.
                Possible values are: `SRC_IPS_V1`.
@@ -31913,6 +31922,8 @@ class SecurityPolicyRuleMatch(dict):
             pulumi.set(__self__, "config", config)
         if expr is not None:
             pulumi.set(__self__, "expr", expr)
+        if expr_options is not None:
+            pulumi.set(__self__, "expr_options", expr_options)
         if versioned_expr is not None:
             pulumi.set(__self__, "versioned_expr", versioned_expr)
 
@@ -31935,6 +31946,15 @@ class SecurityPolicyRuleMatch(dict):
         """
         return pulumi.get(self, "expr")
 
+    @property
+    @pulumi.getter(name="exprOptions")
+    def expr_options(self) -> Optional['outputs.SecurityPolicyRuleMatchExprOptions']:
+        """
+        The configuration options available when specifying a user defined CEVAL expression (i.e., 'expr').
+        Structure is documented below.
+        """
+        return pulumi.get(self, "expr_options")
+
     @property
     @pulumi.getter(name="versionedExpr")
     def versioned_expr(self) -> Optional[str]:
@@ -32000,6 +32020,93 @@ class SecurityPolicyRuleMatchExpr(dict):
         return pulumi.get(self, "expression")
 
 
+@pulumi.output_type
+class SecurityPolicyRuleMatchExprOptions(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "recaptchaOptions":
+            suggest = "recaptcha_options"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in SecurityPolicyRuleMatchExprOptions. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        SecurityPolicyRuleMatchExprOptions.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        SecurityPolicyRuleMatchExprOptions.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 recaptcha_options: 'outputs.SecurityPolicyRuleMatchExprOptionsRecaptchaOptions'):
+        """
+        :param 'SecurityPolicyRuleMatchExprOptionsRecaptchaOptionsArgs' recaptcha_options: reCAPTCHA configuration options to be applied for the rule. If the rule does not evaluate reCAPTCHA tokens, this field has no effect.
+               Structure is documented below.
+        """
+        pulumi.set(__self__, "recaptcha_options", recaptcha_options)
+
+    @property
+    @pulumi.getter(name="recaptchaOptions")
+    def recaptcha_options(self) -> 'outputs.SecurityPolicyRuleMatchExprOptionsRecaptchaOptions':
+        """
+        reCAPTCHA configuration options to be applied for the rule. If the rule does not evaluate reCAPTCHA tokens, this field has no effect.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "recaptcha_options")
+
+
+@pulumi.output_type
+class SecurityPolicyRuleMatchExprOptionsRecaptchaOptions(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "actionTokenSiteKeys":
+            suggest = "action_token_site_keys"
+        elif key == "sessionTokenSiteKeys":
+            suggest = "session_token_site_keys"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in SecurityPolicyRuleMatchExprOptionsRecaptchaOptions. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        SecurityPolicyRuleMatchExprOptionsRecaptchaOptions.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        SecurityPolicyRuleMatchExprOptionsRecaptchaOptions.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 action_token_site_keys: Optional[Sequence[str]] = None,
+                 session_token_site_keys: Optional[Sequence[str]] = None):
+        """
+        :param Sequence[str] action_token_site_keys: A list of site keys to be used during the validation of reCAPTCHA action-tokens. The provided site keys need to be created from reCAPTCHA API under the same project where the security policy is created.
+        :param Sequence[str] session_token_site_keys: A list of site keys to be used during the validation of reCAPTCHA session-tokens. The provided site keys need to be created from reCAPTCHA API under the same project where the security policy is created.
+        """
+        if action_token_site_keys is not None:
+            pulumi.set(__self__, "action_token_site_keys", action_token_site_keys)
+        if session_token_site_keys is not None:
+            pulumi.set(__self__, "session_token_site_keys", session_token_site_keys)
+
+    @property
+    @pulumi.getter(name="actionTokenSiteKeys")
+    def action_token_site_keys(self) -> Optional[Sequence[str]]:
+        """
+        A list of site keys to be used during the validation of reCAPTCHA action-tokens. The provided site keys need to be created from reCAPTCHA API under the same project where the security policy is created.
+        """
+        return pulumi.get(self, "action_token_site_keys")
+
+    @property
+    @pulumi.getter(name="sessionTokenSiteKeys")
+    def session_token_site_keys(self) -> Optional[Sequence[str]]:
+        """
+        A list of site keys to be used during the validation of reCAPTCHA session-tokens. The provided site keys need to be created from reCAPTCHA API under the same project where the security policy is created.
+        """
+        return pulumi.get(self, "session_token_site_keys")
+
+
 @pulumi.output_type
 class SecurityPolicyRulePreconfiguredWafConfig(dict):
     def __init__(__self__, *,
@@ -50463,14 +50570,17 @@ class GetSecurityPolicyRuleHeaderActionRequestHeadersToAddResult(dict):
 class GetSecurityPolicyRuleMatchResult(dict):
     def __init__(__self__, *,
                  configs: Sequence['outputs.GetSecurityPolicyRuleMatchConfigResult'],
+                 expr_options: Sequence['outputs.GetSecurityPolicyRuleMatchExprOptionResult'],
                  exprs: Sequence['outputs.GetSecurityPolicyRuleMatchExprResult'],
                  versioned_expr: str):
         """
         :param Sequence['GetSecurityPolicyRuleMatchConfigArgs'] configs: The configuration options available when specifying versioned_expr. This field must be specified if versioned_expr is specified and cannot be specified if versioned_expr is not specified.
+        :param Sequence['GetSecurityPolicyRuleMatchExprOptionArgs'] expr_options: The configuration options available when specifying a user defined CEVAL expression (i.e., 'expr').
         :param Sequence['GetSecurityPolicyRuleMatchExprArgs'] exprs: User defined CEVAL expression. A CEVAL expression is used to specify match criteria such as origin.ip, source.region_code and contents in the request header.
         :param str versioned_expr: Predefined rule expression. If this field is specified, config must also be specified. Available options:   SRC_IPS_V1: Must specify the corresponding src_ip_ranges field in config.
         """
         pulumi.set(__self__, "configs", configs)
+        pulumi.set(__self__, "expr_options", expr_options)
         pulumi.set(__self__, "exprs", exprs)
         pulumi.set(__self__, "versioned_expr", versioned_expr)
 
@@ -50482,6 +50592,14 @@ class GetSecurityPolicyRuleMatchResult(dict):
         """
         return pulumi.get(self, "configs")
 
+    @property
+    @pulumi.getter(name="exprOptions")
+    def expr_options(self) -> Sequence['outputs.GetSecurityPolicyRuleMatchExprOptionResult']:
+        """
+        The configuration options available when specifying a user defined CEVAL expression (i.e., 'expr').
+        """
+        return pulumi.get(self, "expr_options")
+
     @property
     @pulumi.getter
     def exprs(self) -> Sequence['outputs.GetSecurityPolicyRuleMatchExprResult']:
@@ -50535,6 +50653,53 @@ class GetSecurityPolicyRuleMatchExprResult(dict):
         return pulumi.get(self, "expression")
 
 
+@pulumi.output_type
+class GetSecurityPolicyRuleMatchExprOptionResult(dict):
+    def __init__(__self__, *,
+                 recaptcha_options: Sequence['outputs.GetSecurityPolicyRuleMatchExprOptionRecaptchaOptionResult']):
+        """
+        :param Sequence['GetSecurityPolicyRuleMatchExprOptionRecaptchaOptionArgs'] recaptcha_options: reCAPTCHA configuration options to be applied for the rule. If the rule does not evaluate reCAPTCHA tokens, this field has no effect.
+        """
+        pulumi.set(__self__, "recaptcha_options", recaptcha_options)
+
+    @property
+    @pulumi.getter(name="recaptchaOptions")
+    def recaptcha_options(self) -> Sequence['outputs.GetSecurityPolicyRuleMatchExprOptionRecaptchaOptionResult']:
+        """
+        reCAPTCHA configuration options to be applied for the rule. If the rule does not evaluate reCAPTCHA tokens, this field has no effect.
+        """
+        return pulumi.get(self, "recaptcha_options")
+
+
+@pulumi.output_type
+class GetSecurityPolicyRuleMatchExprOptionRecaptchaOptionResult(dict):
+    def __init__(__self__, *,
+                 action_token_site_keys: Sequence[str],
+                 session_token_site_keys: Sequence[str]):
+        """
+        :param Sequence[str] action_token_site_keys: A list of site keys to be used during the validation of reCAPTCHA action-tokens. The provided site keys need to be created from reCAPTCHA API under the same project where the security policy is created
+        :param Sequence[str] session_token_site_keys: A list of site keys to be used during the validation of reCAPTCHA session-tokens. The provided site keys need to be created from reCAPTCHA API under the same project where the security policy is created.
+        """
+        pulumi.set(__self__, "action_token_site_keys", action_token_site_keys)
+        pulumi.set(__self__, "session_token_site_keys", session_token_site_keys)
+
+    @property
+    @pulumi.getter(name="actionTokenSiteKeys")
+    def action_token_site_keys(self) -> Sequence[str]:
+        """
+        A list of site keys to be used during the validation of reCAPTCHA action-tokens. The provided site keys need to be created from reCAPTCHA API under the same project where the security policy is created
+        """
+        return pulumi.get(self, "action_token_site_keys")
+
+    @property
+    @pulumi.getter(name="sessionTokenSiteKeys")
+    def session_token_site_keys(self) -> Sequence[str]:
+        """
+        A list of site keys to be used during the validation of reCAPTCHA session-tokens. The provided site keys need to be created from reCAPTCHA API under the same project where the security policy is created.
+        """
+        return pulumi.get(self, "session_token_site_keys")
+
+
 @pulumi.output_type
 class GetSecurityPolicyRulePreconfiguredWafConfigResult(dict):
     def __init__(__self__, *,

pulumi_gcp/dataproc/_inputs.py

@@ -96,6 +96,8 @@ __all__ = [
     'MetastoreServiceNetworkConfigArgs',
     'MetastoreServiceNetworkConfigConsumerArgs',
     'MetastoreServiceScalingConfigArgs',
+    'MetastoreServiceScalingConfigAutoscalingConfigArgs',
+    'MetastoreServiceScalingConfigAutoscalingConfigLimitConfigArgs',
     'MetastoreServiceScheduledBackupArgs',
     'MetastoreServiceTelemetryConfigArgs',
     'WorkflowTemplateJobArgs',
@@ -5737,18 +5739,36 @@ class MetastoreServiceNetworkConfigConsumerArgs:
 @pulumi.input_type
 class MetastoreServiceScalingConfigArgs:
     def __init__(__self__, *,
+                 autoscaling_config: Optional[pulumi.Input['MetastoreServiceScalingConfigAutoscalingConfigArgs']] = None,
                  instance_size: Optional[pulumi.Input[str]] = None,
                  scaling_factor: Optional[pulumi.Input[float]] = None):
         """
+        :param pulumi.Input['MetastoreServiceScalingConfigAutoscalingConfigArgs'] autoscaling_config: Represents the autoscaling configuration of a metastore service.
+               Structure is documented below.
         :param pulumi.Input[str] instance_size: Metastore instance sizes.
                Possible values are: `EXTRA_SMALL`, `SMALL`, `MEDIUM`, `LARGE`, `EXTRA_LARGE`.
         :param pulumi.Input[float] scaling_factor: Scaling factor, in increments of 0.1 for values less than 1.0, and increments of 1.0 for values greater than 1.0.
         """
+        if autoscaling_config is not None:
+            pulumi.set(__self__, "autoscaling_config", autoscaling_config)
         if instance_size is not None:
             pulumi.set(__self__, "instance_size", instance_size)
         if scaling_factor is not None:
             pulumi.set(__self__, "scaling_factor", scaling_factor)
 
+    @property
+    @pulumi.getter(name="autoscalingConfig")
+    def autoscaling_config(self) -> Optional[pulumi.Input['MetastoreServiceScalingConfigAutoscalingConfigArgs']]:
+        """
+        Represents the autoscaling configuration of a metastore service.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "autoscaling_config")
+
+    @autoscaling_config.setter
+    def autoscaling_config(self, value: Optional[pulumi.Input['MetastoreServiceScalingConfigAutoscalingConfigArgs']]):
+        pulumi.set(self, "autoscaling_config", value)
+
     @property
     @pulumi.getter(name="instanceSize")
     def instance_size(self) -> Optional[pulumi.Input[str]]:
@@ -5775,6 +5795,86 @@ class MetastoreServiceScalingConfigArgs:
         pulumi.set(self, "scaling_factor", value)
 
 
+@pulumi.input_type
+class MetastoreServiceScalingConfigAutoscalingConfigArgs:
+    def __init__(__self__, *,
+                 autoscaling_enabled: Optional[pulumi.Input[bool]] = None,
+                 limit_config: Optional[pulumi.Input['MetastoreServiceScalingConfigAutoscalingConfigLimitConfigArgs']] = None):
+        """
+        :param pulumi.Input[bool] autoscaling_enabled: Defines whether autoscaling is enabled. The default value is false.
+        :param pulumi.Input['MetastoreServiceScalingConfigAutoscalingConfigLimitConfigArgs'] limit_config: Represents the limit configuration of a metastore service.
+               Structure is documented below.
+        """
+        if autoscaling_enabled is not None:
+            pulumi.set(__self__, "autoscaling_enabled", autoscaling_enabled)
+        if limit_config is not None:
+            pulumi.set(__self__, "limit_config", limit_config)
+
+    @property
+    @pulumi.getter(name="autoscalingEnabled")
+    def autoscaling_enabled(self) -> Optional[pulumi.Input[bool]]:
+        """
+        Defines whether autoscaling is enabled. The default value is false.
+        """
+        return pulumi.get(self, "autoscaling_enabled")
+
+    @autoscaling_enabled.setter
+    def autoscaling_enabled(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "autoscaling_enabled", value)
+
+    @property
+    @pulumi.getter(name="limitConfig")
+    def limit_config(self) -> Optional[pulumi.Input['MetastoreServiceScalingConfigAutoscalingConfigLimitConfigArgs']]:
+        """
+        Represents the limit configuration of a metastore service.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "limit_config")
+
+    @limit_config.setter
+    def limit_config(self, value: Optional[pulumi.Input['MetastoreServiceScalingConfigAutoscalingConfigLimitConfigArgs']]):
+        pulumi.set(self, "limit_config", value)
+
+
+@pulumi.input_type
+class MetastoreServiceScalingConfigAutoscalingConfigLimitConfigArgs:
+    def __init__(__self__, *,
+                 max_scaling_factor: Optional[pulumi.Input[float]] = None,
+                 min_scaling_factor: Optional[pulumi.Input[float]] = None):
+        """
+        :param pulumi.Input[float] max_scaling_factor: The maximum scaling factor that the service will autoscale to. The default value is 6.0.
+        :param pulumi.Input[float] min_scaling_factor: The minimum scaling factor that the service will autoscale to. The default value is 0.1.
+        """
+        if max_scaling_factor is not None:
+            pulumi.set(__self__, "max_scaling_factor", max_scaling_factor)
+        if min_scaling_factor is not None:
+            pulumi.set(__self__, "min_scaling_factor", min_scaling_factor)
+
+    @property
+    @pulumi.getter(name="maxScalingFactor")
+    def max_scaling_factor(self) -> Optional[pulumi.Input[float]]:
+        """
+        The maximum scaling factor that the service will autoscale to. The default value is 6.0.
+        """
+        return pulumi.get(self, "max_scaling_factor")
+
+    @max_scaling_factor.setter
+    def max_scaling_factor(self, value: Optional[pulumi.Input[float]]):
+        pulumi.set(self, "max_scaling_factor", value)
+
+    @property
+    @pulumi.getter(name="minScalingFactor")
+    def min_scaling_factor(self) -> Optional[pulumi.Input[float]]:
+        """
+        The minimum scaling factor that the service will autoscale to. The default value is 0.1.
+        """
+        return pulumi.get(self, "min_scaling_factor")
+
+    @min_scaling_factor.setter
+    def min_scaling_factor(self, value: Optional[pulumi.Input[float]]):
+        pulumi.set(self, "min_scaling_factor", value)
+
+
 @pulumi.input_type
 class MetastoreServiceScheduledBackupArgs:
     def __init__(__self__, *,

pulumi_gcp/dataproc/metastore_service.py

@@ -1005,6 +1005,92 @@ class MetastoreService(pulumi.CustomResource):
                 "env": "test",
             })
         ```
+        ### Dataproc Metastore Service Autoscaling Max Scaling Factor
+
+        ```python
+        import pulumi
+        import pulumi_gcp as gcp
+
+        test_resource = gcp.dataproc.MetastoreService("test_resource",
+            service_id="test-service",
+            location="us-central1",
+            database_type="SPANNER",
+            hive_metastore_config=gcp.dataproc.MetastoreServiceHiveMetastoreConfigArgs(
+                version="3.1.2",
+            ),
+            scaling_config=gcp.dataproc.MetastoreServiceScalingConfigArgs(
+                autoscaling_config=gcp.dataproc.MetastoreServiceScalingConfigAutoscalingConfigArgs(
+                    autoscaling_enabled=True,
+                    limit_config=gcp.dataproc.MetastoreServiceScalingConfigAutoscalingConfigLimitConfigArgs(
+                        max_scaling_factor=1,
+                    ),
+                ),
+            ))
+        ```
+        ### Dataproc Metastore Service Autoscaling Min And Max Scaling Factor
+
+        ```python
+        import pulumi
+        import pulumi_gcp as gcp
+
+        test_resource = gcp.dataproc.MetastoreService("test_resource",
+            service_id="test-service",
+            location="us-central1",
+            database_type="SPANNER",
+            hive_metastore_config=gcp.dataproc.MetastoreServiceHiveMetastoreConfigArgs(
+                version="3.1.2",
+            ),
+            scaling_config=gcp.dataproc.MetastoreServiceScalingConfigArgs(
+                autoscaling_config=gcp.dataproc.MetastoreServiceScalingConfigAutoscalingConfigArgs(
+                    autoscaling_enabled=True,
+                    limit_config=gcp.dataproc.MetastoreServiceScalingConfigAutoscalingConfigLimitConfigArgs(
+                        min_scaling_factor=0.1,
+                        max_scaling_factor=1,
+                    ),
+                ),
+            ))
+        ```
+        ### Dataproc Metastore Service Autoscaling Min Scaling Factor
+
+        ```python
+        import pulumi
+        import pulumi_gcp as gcp
+
+        test_resource = gcp.dataproc.MetastoreService("test_resource",
+            service_id="test-service",
+            location="us-central1",
+            database_type="SPANNER",
+            hive_metastore_config=gcp.dataproc.MetastoreServiceHiveMetastoreConfigArgs(
+                version="3.1.2",
+            ),
+            scaling_config=gcp.dataproc.MetastoreServiceScalingConfigArgs(
+                autoscaling_config=gcp.dataproc.MetastoreServiceScalingConfigAutoscalingConfigArgs(
+                    autoscaling_enabled=True,
+                    limit_config=gcp.dataproc.MetastoreServiceScalingConfigAutoscalingConfigLimitConfigArgs(
+                        min_scaling_factor=0.1,
+                    ),
+                ),
+            ))
+        ```
+        ### Dataproc Metastore Service Autoscaling No Limit Config
+
+        ```python
+        import pulumi
+        import pulumi_gcp as gcp
+
+        test_resource = gcp.dataproc.MetastoreService("test_resource",
+            service_id="test-service",
+            location="us-central1",
+            database_type="SPANNER",
+            hive_metastore_config=gcp.dataproc.MetastoreServiceHiveMetastoreConfigArgs(
+                version="3.1.2",
+            ),
+            scaling_config=gcp.dataproc.MetastoreServiceScalingConfigArgs(
+                autoscaling_config=gcp.dataproc.MetastoreServiceScalingConfigAutoscalingConfigArgs(
+                    autoscaling_enabled=True,
+                ),
+            ))
+        ```
 
         ## Import
 
@@ -1258,6 +1344,92 @@ class MetastoreService(pulumi.CustomResource):
                 "env": "test",
             })
         ```
+        ### Dataproc Metastore Service Autoscaling Max Scaling Factor
+
+        ```python
+        import pulumi
+        import pulumi_gcp as gcp
+
+        test_resource = gcp.dataproc.MetastoreService("test_resource",
+            service_id="test-service",
+            location="us-central1",
+            database_type="SPANNER",
+            hive_metastore_config=gcp.dataproc.MetastoreServiceHiveMetastoreConfigArgs(
+                version="3.1.2",
+            ),
+            scaling_config=gcp.dataproc.MetastoreServiceScalingConfigArgs(
+                autoscaling_config=gcp.dataproc.MetastoreServiceScalingConfigAutoscalingConfigArgs(
+                    autoscaling_enabled=True,
+                    limit_config=gcp.dataproc.MetastoreServiceScalingConfigAutoscalingConfigLimitConfigArgs(
+                        max_scaling_factor=1,
+                    ),
+                ),
+            ))
+        ```
+        ### Dataproc Metastore Service Autoscaling Min And Max Scaling Factor
+
+        ```python
+        import pulumi
+        import pulumi_gcp as gcp
+
+        test_resource = gcp.dataproc.MetastoreService("test_resource",
+            service_id="test-service",
+            location="us-central1",
+            database_type="SPANNER",
+            hive_metastore_config=gcp.dataproc.MetastoreServiceHiveMetastoreConfigArgs(
+                version="3.1.2",
+            ),
+            scaling_config=gcp.dataproc.MetastoreServiceScalingConfigArgs(
+                autoscaling_config=gcp.dataproc.MetastoreServiceScalingConfigAutoscalingConfigArgs(
+                    autoscaling_enabled=True,
+                    limit_config=gcp.dataproc.MetastoreServiceScalingConfigAutoscalingConfigLimitConfigArgs(
+                        min_scaling_factor=0.1,
+                        max_scaling_factor=1,
+                    ),
+                ),
+            ))
+        ```
+        ### Dataproc Metastore Service Autoscaling Min Scaling Factor
+
+        ```python
+        import pulumi
+        import pulumi_gcp as gcp
+
+        test_resource = gcp.dataproc.MetastoreService("test_resource",
+            service_id="test-service",
+            location="us-central1",
+            database_type="SPANNER",
+            hive_metastore_config=gcp.dataproc.MetastoreServiceHiveMetastoreConfigArgs(
+                version="3.1.2",
+            ),
+            scaling_config=gcp.dataproc.MetastoreServiceScalingConfigArgs(
+                autoscaling_config=gcp.dataproc.MetastoreServiceScalingConfigAutoscalingConfigArgs(
+                    autoscaling_enabled=True,
+                    limit_config=gcp.dataproc.MetastoreServiceScalingConfigAutoscalingConfigLimitConfigArgs(
+                        min_scaling_factor=0.1,
+                    ),
+                ),
+            ))
+        ```
+        ### Dataproc Metastore Service Autoscaling No Limit Config
+
+        ```python
+        import pulumi
+        import pulumi_gcp as gcp
+
+        test_resource = gcp.dataproc.MetastoreService("test_resource",
+            service_id="test-service",
+            location="us-central1",
+            database_type="SPANNER",
+            hive_metastore_config=gcp.dataproc.MetastoreServiceHiveMetastoreConfigArgs(
+                version="3.1.2",
+            ),
+            scaling_config=gcp.dataproc.MetastoreServiceScalingConfigArgs(
+                autoscaling_config=gcp.dataproc.MetastoreServiceScalingConfigAutoscalingConfigArgs(
+                    autoscaling_enabled=True,
+                ),
+            ))
+        ```
 
         ## Import