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

pulumi_gcp/config/__init__.pyi

@@ -366,6 +366,8 @@ spannerCustomEndpoint: Optional[str]
 
 sqlCustomEndpoint: Optional[str]
 
+storageBatchOperationsCustomEndpoint: Optional[str]
+
 storageControlCustomEndpoint: Optional[str]
 
 storageCustomEndpoint: Optional[str]

pulumi_gcp/config/vars.py

@@ -722,6 +722,10 @@ class _ExportableConfig(types.ModuleType):
     def sql_custom_endpoint(self) -> Optional[str]:
         return __config__.get('sqlCustomEndpoint')
 
+    @property
+    def storage_batch_operations_custom_endpoint(self) -> Optional[str]:
+        return __config__.get('storageBatchOperationsCustomEndpoint')
+
     @property
     def storage_control_custom_endpoint(self) -> Optional[str]:
         return __config__.get('storageControlCustomEndpoint')

pulumi_gcp/container/_inputs.py

@@ -8526,6 +8526,10 @@ if not MYPY:
         GKE version 1.25.2-gke.1700 or later.
         Structure is documented below.
         """
+        flex_start: NotRequired[pulumi.Input[builtins.bool]]
+        """
+        Enables Flex Start provisioning model for the node pool.
+        """
         gcfs_config: NotRequired[pulumi.Input['ClusterNodeConfigGcfsConfigArgsDict']]
         """
         Parameters for the Google Container Filesystem (GCFS).
@@ -8730,6 +8734,7 @@ class ClusterNodeConfigArgs:
                  ephemeral_storage_config: Optional[pulumi.Input['ClusterNodeConfigEphemeralStorageConfigArgs']] = None,
                  ephemeral_storage_local_ssd_config: Optional[pulumi.Input['ClusterNodeConfigEphemeralStorageLocalSsdConfigArgs']] = None,
                  fast_socket: Optional[pulumi.Input['ClusterNodeConfigFastSocketArgs']] = None,
+                 flex_start: Optional[pulumi.Input[builtins.bool]] = None,
                  gcfs_config: Optional[pulumi.Input['ClusterNodeConfigGcfsConfigArgs']] = None,
                  guest_accelerators: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterNodeConfigGuestAcceleratorArgs']]]] = None,
                  gvnic: Optional[pulumi.Input['ClusterNodeConfigGvnicArgs']] = None,
@@ -8781,6 +8786,7 @@ class ClusterNodeConfigArgs:
                Node Pool must enable gvnic.
                GKE version 1.25.2-gke.1700 or later.
                Structure is documented below.
+        :param pulumi.Input[builtins.bool] flex_start: Enables Flex Start provisioning model for the node pool.
         :param pulumi.Input['ClusterNodeConfigGcfsConfigArgs'] gcfs_config: Parameters for the Google Container Filesystem (GCFS).
                If unspecified, GCFS will not be enabled on the node pool. When enabling this feature you must specify `image_type = "COS_CONTAINERD"` and `node_version` from GKE versions 1.19 or later to use it.
                For GKE versions 1.19, 1.20, and 1.21, the recommended minimum `node_version` would be 1.19.15-gke.1300, 1.20.11-gke.1300, and 1.21.5-gke.1300 respectively.
@@ -8892,6 +8898,8 @@ class ClusterNodeConfigArgs:
             pulumi.set(__self__, "ephemeral_storage_local_ssd_config", ephemeral_storage_local_ssd_config)
         if fast_socket is not None:
             pulumi.set(__self__, "fast_socket", fast_socket)
+        if flex_start is not None:
+            pulumi.set(__self__, "flex_start", flex_start)
         if gcfs_config is not None:
             pulumi.set(__self__, "gcfs_config", gcfs_config)
         if guest_accelerators is not None:
@@ -9097,6 +9105,18 @@ class ClusterNodeConfigArgs:
     def fast_socket(self, value: Optional[pulumi.Input['ClusterNodeConfigFastSocketArgs']]):
         pulumi.set(self, "fast_socket", value)
 
+    @property
+    @pulumi.getter(name="flexStart")
+    def flex_start(self) -> Optional[pulumi.Input[builtins.bool]]:
+        """
+        Enables Flex Start provisioning model for the node pool.
+        """
+        return pulumi.get(self, "flex_start")
+
+    @flex_start.setter
+    def flex_start(self, value: Optional[pulumi.Input[builtins.bool]]):
+        pulumi.set(self, "flex_start", value)
+
     @property
     @pulumi.getter(name="gcfsConfig")
     def gcfs_config(self) -> Optional[pulumi.Input['ClusterNodeConfigGcfsConfigArgs']]:
@@ -12740,6 +12760,10 @@ if not MYPY:
         GKE version 1.25.2-gke.1700 or later.
         Structure is documented below.
         """
+        flex_start: NotRequired[pulumi.Input[builtins.bool]]
+        """
+        Enables Flex Start provisioning model for the node pool.
+        """
         gcfs_config: NotRequired[pulumi.Input['ClusterNodePoolNodeConfigGcfsConfigArgsDict']]
         """
         Parameters for the Google Container Filesystem (GCFS).
@@ -12944,6 +12968,7 @@ class ClusterNodePoolNodeConfigArgs:
                  ephemeral_storage_config: Optional[pulumi.Input['ClusterNodePoolNodeConfigEphemeralStorageConfigArgs']] = None,
                  ephemeral_storage_local_ssd_config: Optional[pulumi.Input['ClusterNodePoolNodeConfigEphemeralStorageLocalSsdConfigArgs']] = None,
                  fast_socket: Optional[pulumi.Input['ClusterNodePoolNodeConfigFastSocketArgs']] = None,
+                 flex_start: Optional[pulumi.Input[builtins.bool]] = None,
                  gcfs_config: Optional[pulumi.Input['ClusterNodePoolNodeConfigGcfsConfigArgs']] = None,
                  guest_accelerators: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterNodePoolNodeConfigGuestAcceleratorArgs']]]] = None,
                  gvnic: Optional[pulumi.Input['ClusterNodePoolNodeConfigGvnicArgs']] = None,
@@ -12995,6 +13020,7 @@ class ClusterNodePoolNodeConfigArgs:
                Node Pool must enable gvnic.
                GKE version 1.25.2-gke.1700 or later.
                Structure is documented below.
+        :param pulumi.Input[builtins.bool] flex_start: Enables Flex Start provisioning model for the node pool.
         :param pulumi.Input['ClusterNodePoolNodeConfigGcfsConfigArgs'] gcfs_config: Parameters for the Google Container Filesystem (GCFS).
                If unspecified, GCFS will not be enabled on the node pool. When enabling this feature you must specify `image_type = "COS_CONTAINERD"` and `node_version` from GKE versions 1.19 or later to use it.
                For GKE versions 1.19, 1.20, and 1.21, the recommended minimum `node_version` would be 1.19.15-gke.1300, 1.20.11-gke.1300, and 1.21.5-gke.1300 respectively.
@@ -13106,6 +13132,8 @@ class ClusterNodePoolNodeConfigArgs:
             pulumi.set(__self__, "ephemeral_storage_local_ssd_config", ephemeral_storage_local_ssd_config)
         if fast_socket is not None:
             pulumi.set(__self__, "fast_socket", fast_socket)
+        if flex_start is not None:
+            pulumi.set(__self__, "flex_start", flex_start)
         if gcfs_config is not None:
             pulumi.set(__self__, "gcfs_config", gcfs_config)
         if guest_accelerators is not None:
@@ -13311,6 +13339,18 @@ class ClusterNodePoolNodeConfigArgs:
     def fast_socket(self, value: Optional[pulumi.Input['ClusterNodePoolNodeConfigFastSocketArgs']]):
         pulumi.set(self, "fast_socket", value)
 
+    @property
+    @pulumi.getter(name="flexStart")
+    def flex_start(self) -> Optional[pulumi.Input[builtins.bool]]:
+        """
+        Enables Flex Start provisioning model for the node pool.
+        """
+        return pulumi.get(self, "flex_start")
+
+    @flex_start.setter
+    def flex_start(self, value: Optional[pulumi.Input[builtins.bool]]):
+        pulumi.set(self, "flex_start", value)
+
     @property
     @pulumi.getter(name="gcfsConfig")
     def gcfs_config(self) -> Optional[pulumi.Input['ClusterNodePoolNodeConfigGcfsConfigArgs']]:
@@ -17506,7 +17546,7 @@ if not MYPY:
         """
         confidential_nodes: NotRequired[pulumi.Input['NodePoolNodeConfigConfidentialNodesArgsDict']]
         """
-        Configuration for the confidential nodes feature, which makes nodes run on confidential VMs. Warning: This configuration can't be changed (or added/removed) after pool creation without deleting and recreating the entire pool.
+        Configuration for the confidential nodes feature, which makes nodes run on confidential VMs.
         """
         containerd_config: NotRequired[pulumi.Input['NodePoolNodeConfigContainerdConfigArgsDict']]
         """
@@ -17540,6 +17580,10 @@ if not MYPY:
         """
         Enable or disable NCCL Fast Socket in the node pool.
         """
+        flex_start: NotRequired[pulumi.Input[builtins.bool]]
+        """
+        Enables Flex Start provisioning model for the node pool
+        """
         gcfs_config: NotRequired[pulumi.Input['NodePoolNodeConfigGcfsConfigArgsDict']]
         """
         GCFS configuration for this node.
@@ -17692,6 +17736,7 @@ class NodePoolNodeConfigArgs:
                  ephemeral_storage_config: Optional[pulumi.Input['NodePoolNodeConfigEphemeralStorageConfigArgs']] = None,
                  ephemeral_storage_local_ssd_config: Optional[pulumi.Input['NodePoolNodeConfigEphemeralStorageLocalSsdConfigArgs']] = None,
                  fast_socket: Optional[pulumi.Input['NodePoolNodeConfigFastSocketArgs']] = None,
+                 flex_start: Optional[pulumi.Input[builtins.bool]] = None,
                  gcfs_config: Optional[pulumi.Input['NodePoolNodeConfigGcfsConfigArgs']] = None,
                  guest_accelerators: Optional[pulumi.Input[Sequence[pulumi.Input['NodePoolNodeConfigGuestAcceleratorArgs']]]] = None,
                  gvnic: Optional[pulumi.Input['NodePoolNodeConfigGvnicArgs']] = None,
@@ -17728,7 +17773,7 @@ class NodePoolNodeConfigArgs:
         """
         :param pulumi.Input['NodePoolNodeConfigAdvancedMachineFeaturesArgs'] advanced_machine_features: Specifies options for controlling advanced machine features.
         :param pulumi.Input[builtins.str] boot_disk_kms_key: The Customer Managed Encryption Key used to encrypt the boot disk attached to each node in the node pool.
-        :param pulumi.Input['NodePoolNodeConfigConfidentialNodesArgs'] confidential_nodes: Configuration for the confidential nodes feature, which makes nodes run on confidential VMs. Warning: This configuration can't be changed (or added/removed) after pool creation without deleting and recreating the entire pool.
+        :param pulumi.Input['NodePoolNodeConfigConfidentialNodesArgs'] confidential_nodes: Configuration for the confidential nodes feature, which makes nodes run on confidential VMs.
         :param pulumi.Input['NodePoolNodeConfigContainerdConfigArgs'] containerd_config: Parameters for containerd configuration.
         :param pulumi.Input[builtins.int] disk_size_gb: Size of the disk attached to each node, specified in GB. The smallest allowed disk size is 10GB.
         :param pulumi.Input[builtins.str] disk_type: Type of the disk attached to each node. Such as pd-standard, pd-balanced or pd-ssd
@@ -17737,6 +17782,7 @@ class NodePoolNodeConfigArgs:
         :param pulumi.Input['NodePoolNodeConfigEphemeralStorageConfigArgs'] ephemeral_storage_config: Parameters for the ephemeral storage filesystem. If unspecified, ephemeral storage is backed by the boot disk.
         :param pulumi.Input['NodePoolNodeConfigEphemeralStorageLocalSsdConfigArgs'] ephemeral_storage_local_ssd_config: Parameters for the ephemeral storage filesystem. If unspecified, ephemeral storage is backed by the boot disk.
         :param pulumi.Input['NodePoolNodeConfigFastSocketArgs'] fast_socket: Enable or disable NCCL Fast Socket in the node pool.
+        :param pulumi.Input[builtins.bool] flex_start: Enables Flex Start provisioning model for the node pool
         :param pulumi.Input['NodePoolNodeConfigGcfsConfigArgs'] gcfs_config: GCFS configuration for this node.
         :param pulumi.Input[Sequence[pulumi.Input['NodePoolNodeConfigGuestAcceleratorArgs']]] guest_accelerators: List of the type and count of accelerator cards attached to the instance.
         :param pulumi.Input['NodePoolNodeConfigGvnicArgs'] gvnic: Enable or disable gvnic in the node pool.
@@ -17796,6 +17842,8 @@ class NodePoolNodeConfigArgs:
             pulumi.set(__self__, "ephemeral_storage_local_ssd_config", ephemeral_storage_local_ssd_config)
         if fast_socket is not None:
             pulumi.set(__self__, "fast_socket", fast_socket)
+        if flex_start is not None:
+            pulumi.set(__self__, "flex_start", flex_start)
         if gcfs_config is not None:
             pulumi.set(__self__, "gcfs_config", gcfs_config)
         if guest_accelerators is not None:
@@ -17891,7 +17939,7 @@ class NodePoolNodeConfigArgs:
     @pulumi.getter(name="confidentialNodes")
     def confidential_nodes(self) -> Optional[pulumi.Input['NodePoolNodeConfigConfidentialNodesArgs']]:
         """
-        Configuration for the confidential nodes feature, which makes nodes run on confidential VMs. Warning: This configuration can't be changed (or added/removed) after pool creation without deleting and recreating the entire pool.
+        Configuration for the confidential nodes feature, which makes nodes run on confidential VMs.
         """
         return pulumi.get(self, "confidential_nodes")
 
@@ -17995,6 +18043,18 @@ class NodePoolNodeConfigArgs:
     def fast_socket(self, value: Optional[pulumi.Input['NodePoolNodeConfigFastSocketArgs']]):
         pulumi.set(self, "fast_socket", value)
 
+    @property
+    @pulumi.getter(name="flexStart")
+    def flex_start(self) -> Optional[pulumi.Input[builtins.bool]]:
+        """
+        Enables Flex Start provisioning model for the node pool
+        """
+        return pulumi.get(self, "flex_start")
+
+    @flex_start.setter
+    def flex_start(self, value: Optional[pulumi.Input[builtins.bool]]):
+        pulumi.set(self, "flex_start", value)
+
     @property
     @pulumi.getter(name="gcfsConfig")
     def gcfs_config(self) -> Optional[pulumi.Input['NodePoolNodeConfigGcfsConfigArgs']]:

pulumi_gcp/container/outputs.py

@@ -6994,6 +6994,8 @@ class ClusterNodeConfig(dict):
             suggest = "ephemeral_storage_local_ssd_config"
         elif key == "fastSocket":
             suggest = "fast_socket"
+        elif key == "flexStart":
+            suggest = "flex_start"
         elif key == "gcfsConfig":
             suggest = "gcfs_config"
         elif key == "guestAccelerators":
@@ -7070,6 +7072,7 @@ class ClusterNodeConfig(dict):
                  ephemeral_storage_config: Optional['outputs.ClusterNodeConfigEphemeralStorageConfig'] = None,
                  ephemeral_storage_local_ssd_config: Optional['outputs.ClusterNodeConfigEphemeralStorageLocalSsdConfig'] = None,
                  fast_socket: Optional['outputs.ClusterNodeConfigFastSocket'] = None,
+                 flex_start: Optional[builtins.bool] = None,
                  gcfs_config: Optional['outputs.ClusterNodeConfigGcfsConfig'] = None,
                  guest_accelerators: Optional[Sequence['outputs.ClusterNodeConfigGuestAccelerator']] = None,
                  gvnic: Optional['outputs.ClusterNodeConfigGvnic'] = None,
@@ -7121,6 +7124,7 @@ class ClusterNodeConfig(dict):
                Node Pool must enable gvnic.
                GKE version 1.25.2-gke.1700 or later.
                Structure is documented below.
+        :param builtins.bool flex_start: Enables Flex Start provisioning model for the node pool.
         :param 'ClusterNodeConfigGcfsConfigArgs' gcfs_config: Parameters for the Google Container Filesystem (GCFS).
                If unspecified, GCFS will not be enabled on the node pool. When enabling this feature you must specify `image_type = "COS_CONTAINERD"` and `node_version` from GKE versions 1.19 or later to use it.
                For GKE versions 1.19, 1.20, and 1.21, the recommended minimum `node_version` would be 1.19.15-gke.1300, 1.20.11-gke.1300, and 1.21.5-gke.1300 respectively.
@@ -7232,6 +7236,8 @@ class ClusterNodeConfig(dict):
             pulumi.set(__self__, "ephemeral_storage_local_ssd_config", ephemeral_storage_local_ssd_config)
         if fast_socket is not None:
             pulumi.set(__self__, "fast_socket", fast_socket)
+        if flex_start is not None:
+            pulumi.set(__self__, "flex_start", flex_start)
         if gcfs_config is not None:
             pulumi.set(__self__, "gcfs_config", gcfs_config)
         if guest_accelerators is not None:
@@ -7393,6 +7399,14 @@ class ClusterNodeConfig(dict):
         """
         return pulumi.get(self, "fast_socket")
 
+    @property
+    @pulumi.getter(name="flexStart")
+    def flex_start(self) -> Optional[builtins.bool]:
+        """
+        Enables Flex Start provisioning model for the node pool.
+        """
+        return pulumi.get(self, "flex_start")
+
     @property
     @pulumi.getter(name="gcfsConfig")
     def gcfs_config(self) -> Optional['outputs.ClusterNodeConfigGcfsConfig']:
@@ -10307,6 +10321,8 @@ class ClusterNodePoolNodeConfig(dict):
             suggest = "ephemeral_storage_local_ssd_config"
         elif key == "fastSocket":
             suggest = "fast_socket"
+        elif key == "flexStart":
+            suggest = "flex_start"
         elif key == "gcfsConfig":
             suggest = "gcfs_config"
         elif key == "guestAccelerators":
@@ -10383,6 +10399,7 @@ class ClusterNodePoolNodeConfig(dict):
                  ephemeral_storage_config: Optional['outputs.ClusterNodePoolNodeConfigEphemeralStorageConfig'] = None,
                  ephemeral_storage_local_ssd_config: Optional['outputs.ClusterNodePoolNodeConfigEphemeralStorageLocalSsdConfig'] = None,
                  fast_socket: Optional['outputs.ClusterNodePoolNodeConfigFastSocket'] = None,
+                 flex_start: Optional[builtins.bool] = None,
                  gcfs_config: Optional['outputs.ClusterNodePoolNodeConfigGcfsConfig'] = None,
                  guest_accelerators: Optional[Sequence['outputs.ClusterNodePoolNodeConfigGuestAccelerator']] = None,
                  gvnic: Optional['outputs.ClusterNodePoolNodeConfigGvnic'] = None,
@@ -10434,6 +10451,7 @@ class ClusterNodePoolNodeConfig(dict):
                Node Pool must enable gvnic.
                GKE version 1.25.2-gke.1700 or later.
                Structure is documented below.
+        :param builtins.bool flex_start: Enables Flex Start provisioning model for the node pool.
         :param 'ClusterNodePoolNodeConfigGcfsConfigArgs' gcfs_config: Parameters for the Google Container Filesystem (GCFS).
                If unspecified, GCFS will not be enabled on the node pool. When enabling this feature you must specify `image_type = "COS_CONTAINERD"` and `node_version` from GKE versions 1.19 or later to use it.
                For GKE versions 1.19, 1.20, and 1.21, the recommended minimum `node_version` would be 1.19.15-gke.1300, 1.20.11-gke.1300, and 1.21.5-gke.1300 respectively.
@@ -10545,6 +10563,8 @@ class ClusterNodePoolNodeConfig(dict):
             pulumi.set(__self__, "ephemeral_storage_local_ssd_config", ephemeral_storage_local_ssd_config)
         if fast_socket is not None:
             pulumi.set(__self__, "fast_socket", fast_socket)
+        if flex_start is not None:
+            pulumi.set(__self__, "flex_start", flex_start)
         if gcfs_config is not None:
             pulumi.set(__self__, "gcfs_config", gcfs_config)
         if guest_accelerators is not None:
@@ -10706,6 +10726,14 @@ class ClusterNodePoolNodeConfig(dict):
         """
         return pulumi.get(self, "fast_socket")
 
+    @property
+    @pulumi.getter(name="flexStart")
+    def flex_start(self) -> Optional[builtins.bool]:
+        """
+        Enables Flex Start provisioning model for the node pool.
+        """
+        return pulumi.get(self, "flex_start")
+
     @property
     @pulumi.getter(name="gcfsConfig")
     def gcfs_config(self) -> Optional['outputs.ClusterNodePoolNodeConfigGcfsConfig']:
@@ -14086,6 +14114,8 @@ class NodePoolNodeConfig(dict):
             suggest = "ephemeral_storage_local_ssd_config"
         elif key == "fastSocket":
             suggest = "fast_socket"
+        elif key == "flexStart":
+            suggest = "flex_start"
         elif key == "gcfsConfig":
             suggest = "gcfs_config"
         elif key == "guestAccelerators":
@@ -14162,6 +14192,7 @@ class NodePoolNodeConfig(dict):
                  ephemeral_storage_config: Optional['outputs.NodePoolNodeConfigEphemeralStorageConfig'] = None,
                  ephemeral_storage_local_ssd_config: Optional['outputs.NodePoolNodeConfigEphemeralStorageLocalSsdConfig'] = None,
                  fast_socket: Optional['outputs.NodePoolNodeConfigFastSocket'] = None,
+                 flex_start: Optional[builtins.bool] = None,
                  gcfs_config: Optional['outputs.NodePoolNodeConfigGcfsConfig'] = None,
                  guest_accelerators: Optional[Sequence['outputs.NodePoolNodeConfigGuestAccelerator']] = None,
                  gvnic: Optional['outputs.NodePoolNodeConfigGvnic'] = None,
@@ -14198,7 +14229,7 @@ class NodePoolNodeConfig(dict):
         """
         :param 'NodePoolNodeConfigAdvancedMachineFeaturesArgs' advanced_machine_features: Specifies options for controlling advanced machine features.
         :param builtins.str boot_disk_kms_key: The Customer Managed Encryption Key used to encrypt the boot disk attached to each node in the node pool.
-        :param 'NodePoolNodeConfigConfidentialNodesArgs' confidential_nodes: Configuration for the confidential nodes feature, which makes nodes run on confidential VMs. Warning: This configuration can't be changed (or added/removed) after pool creation without deleting and recreating the entire pool.
+        :param 'NodePoolNodeConfigConfidentialNodesArgs' confidential_nodes: Configuration for the confidential nodes feature, which makes nodes run on confidential VMs.
         :param 'NodePoolNodeConfigContainerdConfigArgs' containerd_config: Parameters for containerd configuration.
         :param builtins.int disk_size_gb: Size of the disk attached to each node, specified in GB. The smallest allowed disk size is 10GB.
         :param builtins.str disk_type: Type of the disk attached to each node. Such as pd-standard, pd-balanced or pd-ssd
@@ -14207,6 +14238,7 @@ class NodePoolNodeConfig(dict):
         :param 'NodePoolNodeConfigEphemeralStorageConfigArgs' ephemeral_storage_config: Parameters for the ephemeral storage filesystem. If unspecified, ephemeral storage is backed by the boot disk.
         :param 'NodePoolNodeConfigEphemeralStorageLocalSsdConfigArgs' ephemeral_storage_local_ssd_config: Parameters for the ephemeral storage filesystem. If unspecified, ephemeral storage is backed by the boot disk.
         :param 'NodePoolNodeConfigFastSocketArgs' fast_socket: Enable or disable NCCL Fast Socket in the node pool.
+        :param builtins.bool flex_start: Enables Flex Start provisioning model for the node pool
         :param 'NodePoolNodeConfigGcfsConfigArgs' gcfs_config: GCFS configuration for this node.
         :param Sequence['NodePoolNodeConfigGuestAcceleratorArgs'] guest_accelerators: List of the type and count of accelerator cards attached to the instance.
         :param 'NodePoolNodeConfigGvnicArgs' gvnic: Enable or disable gvnic in the node pool.
@@ -14266,6 +14298,8 @@ class NodePoolNodeConfig(dict):
             pulumi.set(__self__, "ephemeral_storage_local_ssd_config", ephemeral_storage_local_ssd_config)
         if fast_socket is not None:
             pulumi.set(__self__, "fast_socket", fast_socket)
+        if flex_start is not None:
+            pulumi.set(__self__, "flex_start", flex_start)
         if gcfs_config is not None:
             pulumi.set(__self__, "gcfs_config", gcfs_config)
         if guest_accelerators is not None:
@@ -14353,7 +14387,7 @@ class NodePoolNodeConfig(dict):
     @pulumi.getter(name="confidentialNodes")
     def confidential_nodes(self) -> Optional['outputs.NodePoolNodeConfigConfidentialNodes']:
         """
-        Configuration for the confidential nodes feature, which makes nodes run on confidential VMs. Warning: This configuration can't be changed (or added/removed) after pool creation without deleting and recreating the entire pool.
+        Configuration for the confidential nodes feature, which makes nodes run on confidential VMs.
         """
         return pulumi.get(self, "confidential_nodes")
 
@@ -14421,6 +14455,14 @@ class NodePoolNodeConfig(dict):
         """
         return pulumi.get(self, "fast_socket")
 
+    @property
+    @pulumi.getter(name="flexStart")
+    def flex_start(self) -> Optional[builtins.bool]:
+        """
+        Enables Flex Start provisioning model for the node pool
+        """
+        return pulumi.get(self, "flex_start")
+
     @property
     @pulumi.getter(name="gcfsConfig")
     def gcfs_config(self) -> Optional['outputs.NodePoolNodeConfigGcfsConfig']:
@@ -18155,6 +18197,7 @@ class GetClusterNodeConfigResult(dict):
                  ephemeral_storage_configs: Sequence['outputs.GetClusterNodeConfigEphemeralStorageConfigResult'],
                  ephemeral_storage_local_ssd_configs: Sequence['outputs.GetClusterNodeConfigEphemeralStorageLocalSsdConfigResult'],
                  fast_sockets: Sequence['outputs.GetClusterNodeConfigFastSocketResult'],
+                 flex_start: builtins.bool,
                  gcfs_configs: Sequence['outputs.GetClusterNodeConfigGcfsConfigResult'],
                  guest_accelerators: Sequence['outputs.GetClusterNodeConfigGuestAcceleratorResult'],
                  gvnics: Sequence['outputs.GetClusterNodeConfigGvnicResult'],
@@ -18191,7 +18234,7 @@ class GetClusterNodeConfigResult(dict):
         """
         :param Sequence['GetClusterNodeConfigAdvancedMachineFeatureArgs'] advanced_machine_features: Specifies options for controlling advanced machine features.
         :param builtins.str boot_disk_kms_key: The Customer Managed Encryption Key used to encrypt the boot disk attached to each node in the node pool.
-        :param Sequence['GetClusterNodeConfigConfidentialNodeArgs'] confidential_nodes: Configuration for the confidential nodes feature, which makes nodes run on confidential VMs. Warning: This configuration can't be changed (or added/removed) after pool creation without deleting and recreating the entire pool.
+        :param Sequence['GetClusterNodeConfigConfidentialNodeArgs'] confidential_nodes: Configuration for the confidential nodes feature, which makes nodes run on confidential VMs.
         :param Sequence['GetClusterNodeConfigContainerdConfigArgs'] containerd_configs: Parameters for containerd configuration.
         :param builtins.int disk_size_gb: Size of the disk attached to each node, specified in GB. The smallest allowed disk size is 10GB.
         :param builtins.str disk_type: Type of the disk attached to each node. Such as pd-standard, pd-balanced or pd-ssd
@@ -18200,6 +18243,7 @@ class GetClusterNodeConfigResult(dict):
         :param Sequence['GetClusterNodeConfigEphemeralStorageConfigArgs'] ephemeral_storage_configs: Parameters for the ephemeral storage filesystem. If unspecified, ephemeral storage is backed by the boot disk.
         :param Sequence['GetClusterNodeConfigEphemeralStorageLocalSsdConfigArgs'] ephemeral_storage_local_ssd_configs: Parameters for the ephemeral storage filesystem. If unspecified, ephemeral storage is backed by the boot disk.
         :param Sequence['GetClusterNodeConfigFastSocketArgs'] fast_sockets: Enable or disable NCCL Fast Socket in the node pool.
+        :param builtins.bool flex_start: Enables Flex Start provisioning model for the node pool
         :param Sequence['GetClusterNodeConfigGcfsConfigArgs'] gcfs_configs: GCFS configuration for this node.
         :param Sequence['GetClusterNodeConfigGuestAcceleratorArgs'] guest_accelerators: List of the type and count of accelerator cards attached to the instance.
         :param Sequence['GetClusterNodeConfigGvnicArgs'] gvnics: Enable or disable gvnic in the node pool.
@@ -18245,6 +18289,7 @@ class GetClusterNodeConfigResult(dict):
         pulumi.set(__self__, "ephemeral_storage_configs", ephemeral_storage_configs)
         pulumi.set(__self__, "ephemeral_storage_local_ssd_configs", ephemeral_storage_local_ssd_configs)
         pulumi.set(__self__, "fast_sockets", fast_sockets)
+        pulumi.set(__self__, "flex_start", flex_start)
         pulumi.set(__self__, "gcfs_configs", gcfs_configs)
         pulumi.set(__self__, "guest_accelerators", guest_accelerators)
         pulumi.set(__self__, "gvnics", gvnics)
@@ -18299,7 +18344,7 @@ class GetClusterNodeConfigResult(dict):
     @pulumi.getter(name="confidentialNodes")
     def confidential_nodes(self) -> Sequence['outputs.GetClusterNodeConfigConfidentialNodeResult']:
         """
-        Configuration for the confidential nodes feature, which makes nodes run on confidential VMs. Warning: This configuration can't be changed (or added/removed) after pool creation without deleting and recreating the entire pool.
+        Configuration for the confidential nodes feature, which makes nodes run on confidential VMs.
         """
         return pulumi.get(self, "confidential_nodes")
 
@@ -18367,6 +18412,14 @@ class GetClusterNodeConfigResult(dict):
         """
         return pulumi.get(self, "fast_sockets")
 
+    @property
+    @pulumi.getter(name="flexStart")
+    def flex_start(self) -> builtins.bool:
+        """
+        Enables Flex Start provisioning model for the node pool
+        """
+        return pulumi.get(self, "flex_start")
+
     @property
     @pulumi.getter(name="gcfsConfigs")
     def gcfs_configs(self) -> Sequence['outputs.GetClusterNodeConfigGcfsConfigResult']:
@@ -20270,6 +20323,7 @@ class GetClusterNodePoolNodeConfigResult(dict):
                  ephemeral_storage_configs: Sequence['outputs.GetClusterNodePoolNodeConfigEphemeralStorageConfigResult'],
                  ephemeral_storage_local_ssd_configs: Sequence['outputs.GetClusterNodePoolNodeConfigEphemeralStorageLocalSsdConfigResult'],
                  fast_sockets: Sequence['outputs.GetClusterNodePoolNodeConfigFastSocketResult'],
+                 flex_start: builtins.bool,
                  gcfs_configs: Sequence['outputs.GetClusterNodePoolNodeConfigGcfsConfigResult'],
                  guest_accelerators: Sequence['outputs.GetClusterNodePoolNodeConfigGuestAcceleratorResult'],
                  gvnics: Sequence['outputs.GetClusterNodePoolNodeConfigGvnicResult'],
@@ -20306,7 +20360,7 @@ class GetClusterNodePoolNodeConfigResult(dict):
         """
         :param Sequence['GetClusterNodePoolNodeConfigAdvancedMachineFeatureArgs'] advanced_machine_features: Specifies options for controlling advanced machine features.
         :param builtins.str boot_disk_kms_key: The Customer Managed Encryption Key used to encrypt the boot disk attached to each node in the node pool.
-        :param Sequence['GetClusterNodePoolNodeConfigConfidentialNodeArgs'] confidential_nodes: Configuration for the confidential nodes feature, which makes nodes run on confidential VMs. Warning: This configuration can't be changed (or added/removed) after pool creation without deleting and recreating the entire pool.
+        :param Sequence['GetClusterNodePoolNodeConfigConfidentialNodeArgs'] confidential_nodes: Configuration for the confidential nodes feature, which makes nodes run on confidential VMs.
         :param Sequence['GetClusterNodePoolNodeConfigContainerdConfigArgs'] containerd_configs: Parameters for containerd configuration.
         :param builtins.int disk_size_gb: Size of the disk attached to each node, specified in GB. The smallest allowed disk size is 10GB.
         :param builtins.str disk_type: Type of the disk attached to each node. Such as pd-standard, pd-balanced or pd-ssd
@@ -20315,6 +20369,7 @@ class GetClusterNodePoolNodeConfigResult(dict):
         :param Sequence['GetClusterNodePoolNodeConfigEphemeralStorageConfigArgs'] ephemeral_storage_configs: Parameters for the ephemeral storage filesystem. If unspecified, ephemeral storage is backed by the boot disk.
         :param Sequence['GetClusterNodePoolNodeConfigEphemeralStorageLocalSsdConfigArgs'] ephemeral_storage_local_ssd_configs: Parameters for the ephemeral storage filesystem. If unspecified, ephemeral storage is backed by the boot disk.
         :param Sequence['GetClusterNodePoolNodeConfigFastSocketArgs'] fast_sockets: Enable or disable NCCL Fast Socket in the node pool.
+        :param builtins.bool flex_start: Enables Flex Start provisioning model for the node pool
         :param Sequence['GetClusterNodePoolNodeConfigGcfsConfigArgs'] gcfs_configs: GCFS configuration for this node.
         :param Sequence['GetClusterNodePoolNodeConfigGuestAcceleratorArgs'] guest_accelerators: List of the type and count of accelerator cards attached to the instance.
         :param Sequence['GetClusterNodePoolNodeConfigGvnicArgs'] gvnics: Enable or disable gvnic in the node pool.
@@ -20360,6 +20415,7 @@ class GetClusterNodePoolNodeConfigResult(dict):
         pulumi.set(__self__, "ephemeral_storage_configs", ephemeral_storage_configs)
         pulumi.set(__self__, "ephemeral_storage_local_ssd_configs", ephemeral_storage_local_ssd_configs)
         pulumi.set(__self__, "fast_sockets", fast_sockets)
+        pulumi.set(__self__, "flex_start", flex_start)
         pulumi.set(__self__, "gcfs_configs", gcfs_configs)
         pulumi.set(__self__, "guest_accelerators", guest_accelerators)
         pulumi.set(__self__, "gvnics", gvnics)
@@ -20414,7 +20470,7 @@ class GetClusterNodePoolNodeConfigResult(dict):
     @pulumi.getter(name="confidentialNodes")
     def confidential_nodes(self) -> Sequence['outputs.GetClusterNodePoolNodeConfigConfidentialNodeResult']:
         """
-        Configuration for the confidential nodes feature, which makes nodes run on confidential VMs. Warning: This configuration can't be changed (or added/removed) after pool creation without deleting and recreating the entire pool.
+        Configuration for the confidential nodes feature, which makes nodes run on confidential VMs.
         """
         return pulumi.get(self, "confidential_nodes")
 
@@ -20482,6 +20538,14 @@ class GetClusterNodePoolNodeConfigResult(dict):
         """
         return pulumi.get(self, "fast_sockets")
 
+    @property
+    @pulumi.getter(name="flexStart")
+    def flex_start(self) -> builtins.bool:
+        """
+        Enables Flex Start provisioning model for the node pool
+        """
+        return pulumi.get(self, "flex_start")
+
     @property
     @pulumi.getter(name="gcfsConfigs")
     def gcfs_configs(self) -> Sequence['outputs.GetClusterNodePoolNodeConfigGcfsConfigResult']:

pulumi_gcp/dataproc/get_metastore_service.py

@@ -28,7 +28,7 @@ class GetMetastoreServiceResult:
     """
     A collection of values returned by getMetastoreService.
     """
-    def __init__(__self__, artifact_gcs_uri=None, create_time=None, database_type=None, deletion_protection=None, effective_labels=None, encryption_configs=None, endpoint_uri=None, hive_metastore_configs=None, id=None, labels=None, location=None, maintenance_windows=None, metadata_integrations=None, name=None, network=None, network_configs=None, port=None, project=None, pulumi_labels=None, release_channel=None, scaling_configs=None, scheduled_backups=None, service_id=None, state=None, state_message=None, telemetry_configs=None, tier=None, uid=None, update_time=None):
+    def __init__(__self__, artifact_gcs_uri=None, create_time=None, database_type=None, deletion_protection=None, effective_labels=None, encryption_configs=None, endpoint_uri=None, hive_metastore_configs=None, id=None, labels=None, location=None, maintenance_windows=None, metadata_integrations=None, name=None, network=None, network_configs=None, port=None, project=None, pulumi_labels=None, release_channel=None, scaling_configs=None, scheduled_backups=None, service_id=None, state=None, state_message=None, tags=None, telemetry_configs=None, tier=None, uid=None, update_time=None):
         if artifact_gcs_uri and not isinstance(artifact_gcs_uri, str):
             raise TypeError("Expected argument 'artifact_gcs_uri' to be a str")
         pulumi.set(__self__, "artifact_gcs_uri", artifact_gcs_uri)
@@ -104,6 +104,9 @@ class GetMetastoreServiceResult:
         if state_message and not isinstance(state_message, str):
             raise TypeError("Expected argument 'state_message' to be a str")
         pulumi.set(__self__, "state_message", state_message)
+        if tags and not isinstance(tags, dict):
+            raise TypeError("Expected argument 'tags' to be a dict")
+        pulumi.set(__self__, "tags", tags)
         if telemetry_configs and not isinstance(telemetry_configs, list):
             raise TypeError("Expected argument 'telemetry_configs' to be a list")
         pulumi.set(__self__, "telemetry_configs", telemetry_configs)
@@ -245,6 +248,11 @@ class GetMetastoreServiceResult:
     def state_message(self) -> builtins.str:
         return pulumi.get(self, "state_message")
 
+    @property
+    @pulumi.getter
+    def tags(self) -> Mapping[str, builtins.str]:
+        return pulumi.get(self, "tags")
+
     @property
     @pulumi.getter(name="telemetryConfigs")
     def telemetry_configs(self) -> Sequence['outputs.GetMetastoreServiceTelemetryConfigResult']:
@@ -297,6 +305,7 @@ class AwaitableGetMetastoreServiceResult(GetMetastoreServiceResult):
             service_id=self.service_id,
             state=self.state,
             state_message=self.state_message,
+            tags=self.tags,
             telemetry_configs=self.telemetry_configs,
             tier=self.tier,
             uid=self.uid,
@@ -361,6 +370,7 @@ def get_metastore_service(location: Optional[builtins.str] = None,
         service_id=pulumi.get(__ret__, 'service_id'),
         state=pulumi.get(__ret__, 'state'),
         state_message=pulumi.get(__ret__, 'state_message'),
+        tags=pulumi.get(__ret__, 'tags'),
         telemetry_configs=pulumi.get(__ret__, 'telemetry_configs'),
         tier=pulumi.get(__ret__, 'tier'),
         uid=pulumi.get(__ret__, 'uid'),
@@ -422,6 +432,7 @@ def get_metastore_service_output(location: Optional[pulumi.Input[builtins.str]]
         service_id=pulumi.get(__response__, 'service_id'),
         state=pulumi.get(__response__, 'state'),
         state_message=pulumi.get(__response__, 'state_message'),
+        tags=pulumi.get(__response__, 'tags'),
         telemetry_configs=pulumi.get(__response__, 'telemetry_configs'),
         tier=pulumi.get(__response__, 'tier'),
         uid=pulumi.get(__response__, 'uid'),