pulumi-gcp 7.15.0a1711038061__py3-none-any.whl → 7.16.0__py3-none-any.whl

pulumi_gcp/workstations/outputs.py

@@ -17,9 +17,13 @@ __all__ = [
     'WorkstationConfigCondition',
     'WorkstationConfigContainer',
     'WorkstationConfigEncryptionKey',
+    'WorkstationConfigEphemeralDirectory',
+    'WorkstationConfigEphemeralDirectoryGcePd',
     'WorkstationConfigHost',
     'WorkstationConfigHostGceInstance',
     'WorkstationConfigHostGceInstanceAccelerator',
+    'WorkstationConfigHostGceInstanceBoostConfig',
+    'WorkstationConfigHostGceInstanceBoostConfigAccelerator',
     'WorkstationConfigHostGceInstanceConfidentialInstanceConfig',
     'WorkstationConfigHostGceInstanceShieldedInstanceConfig',
     'WorkstationConfigIamBindingCondition',
@@ -386,6 +390,146 @@ class WorkstationConfigEncryptionKey(dict):
         return pulumi.get(self, "kms_key_service_account")
 
 
+@pulumi.output_type
+class WorkstationConfigEphemeralDirectory(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "gcePd":
+            suggest = "gce_pd"
+        elif key == "mountPath":
+            suggest = "mount_path"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in WorkstationConfigEphemeralDirectory. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        WorkstationConfigEphemeralDirectory.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        WorkstationConfigEphemeralDirectory.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 gce_pd: Optional['outputs.WorkstationConfigEphemeralDirectoryGcePd'] = None,
+                 mount_path: Optional[str] = None):
+        """
+        :param 'WorkstationConfigEphemeralDirectoryGcePdArgs' gce_pd: An EphemeralDirectory backed by a Compute Engine persistent disk.
+               Structure is documented below.
+        :param str mount_path: Location of this directory in the running workstation.
+        """
+        if gce_pd is not None:
+            pulumi.set(__self__, "gce_pd", gce_pd)
+        if mount_path is not None:
+            pulumi.set(__self__, "mount_path", mount_path)
+
+    @property
+    @pulumi.getter(name="gcePd")
+    def gce_pd(self) -> Optional['outputs.WorkstationConfigEphemeralDirectoryGcePd']:
+        """
+        An EphemeralDirectory backed by a Compute Engine persistent disk.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "gce_pd")
+
+    @property
+    @pulumi.getter(name="mountPath")
+    def mount_path(self) -> Optional[str]:
+        """
+        Location of this directory in the running workstation.
+        """
+        return pulumi.get(self, "mount_path")
+
+
+@pulumi.output_type
+class WorkstationConfigEphemeralDirectoryGcePd(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "diskType":
+            suggest = "disk_type"
+        elif key == "readOnly":
+            suggest = "read_only"
+        elif key == "sourceImage":
+            suggest = "source_image"
+        elif key == "sourceSnapshot":
+            suggest = "source_snapshot"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in WorkstationConfigEphemeralDirectoryGcePd. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        WorkstationConfigEphemeralDirectoryGcePd.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        WorkstationConfigEphemeralDirectoryGcePd.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 disk_type: Optional[str] = None,
+                 read_only: Optional[bool] = None,
+                 source_image: Optional[str] = None,
+                 source_snapshot: Optional[str] = None):
+        """
+        :param str disk_type: Type of the disk to use. Defaults to `"pd-standard"`.
+        :param bool read_only: Whether the disk is read only. If true, the disk may be shared by multiple VMs and `sourceSnapshot` must be set.
+        :param str source_image: Name of the disk image to use as the source for the disk.
+               Must be empty `sourceSnapshot` is set.
+               Updating `sourceImage` will update content in the ephemeral directory after the workstation is restarted.
+        :param str source_snapshot: Name of the snapshot to use as the source for the disk.
+               Must be empty if `sourceImage` is set.
+               Must be empty if `read_only` is false.
+               Updating `source_snapshot` will update content in the ephemeral directory after the workstation is restarted.
+        """
+        if disk_type is not None:
+            pulumi.set(__self__, "disk_type", disk_type)
+        if read_only is not None:
+            pulumi.set(__self__, "read_only", read_only)
+        if source_image is not None:
+            pulumi.set(__self__, "source_image", source_image)
+        if source_snapshot is not None:
+            pulumi.set(__self__, "source_snapshot", source_snapshot)
+
+    @property
+    @pulumi.getter(name="diskType")
+    def disk_type(self) -> Optional[str]:
+        """
+        Type of the disk to use. Defaults to `"pd-standard"`.
+        """
+        return pulumi.get(self, "disk_type")
+
+    @property
+    @pulumi.getter(name="readOnly")
+    def read_only(self) -> Optional[bool]:
+        """
+        Whether the disk is read only. If true, the disk may be shared by multiple VMs and `sourceSnapshot` must be set.
+        """
+        return pulumi.get(self, "read_only")
+
+    @property
+    @pulumi.getter(name="sourceImage")
+    def source_image(self) -> Optional[str]:
+        """
+        Name of the disk image to use as the source for the disk.
+        Must be empty `sourceSnapshot` is set.
+        Updating `sourceImage` will update content in the ephemeral directory after the workstation is restarted.
+        """
+        return pulumi.get(self, "source_image")
+
+    @property
+    @pulumi.getter(name="sourceSnapshot")
+    def source_snapshot(self) -> Optional[str]:
+        """
+        Name of the snapshot to use as the source for the disk.
+        Must be empty if `sourceImage` is set.
+        Must be empty if `read_only` is false.
+        Updating `source_snapshot` will update content in the ephemeral directory after the workstation is restarted.
+        """
+        return pulumi.get(self, "source_snapshot")
+
+
 @pulumi.output_type
 class WorkstationConfigHost(dict):
     @staticmethod
@@ -429,7 +573,9 @@ class WorkstationConfigHostGceInstance(dict):
     @staticmethod
     def __key_warning(key: str):
         suggest = None
-        if key == "bootDiskSizeGb":
+        if key == "boostConfigs":
+            suggest = "boost_configs"
+        elif key == "bootDiskSizeGb":
             suggest = "boot_disk_size_gb"
         elif key == "confidentialInstanceConfig":
             suggest = "confidential_instance_config"
@@ -463,6 +609,7 @@ class WorkstationConfigHostGceInstance(dict):
 
     def __init__(__self__, *,
                  accelerators: Optional[Sequence['outputs.WorkstationConfigHostGceInstanceAccelerator']] = None,
+                 boost_configs: Optional[Sequence['outputs.WorkstationConfigHostGceInstanceBoostConfig']] = None,
                  boot_disk_size_gb: Optional[int] = None,
                  confidential_instance_config: Optional['outputs.WorkstationConfigHostGceInstanceConfidentialInstanceConfig'] = None,
                  disable_public_ip_addresses: Optional[bool] = None,
@@ -477,6 +624,8 @@ class WorkstationConfigHostGceInstance(dict):
         """
         :param Sequence['WorkstationConfigHostGceInstanceAcceleratorArgs'] accelerators: An accelerator card attached to the instance.
                Structure is documented below.
+        :param Sequence['WorkstationConfigHostGceInstanceBoostConfigArgs'] boost_configs: A list of the boost configurations that workstations created using this workstation configuration are allowed to use.
+               Structure is documented below.
         :param int boot_disk_size_gb: Size of the boot disk in GB.
         :param 'WorkstationConfigHostGceInstanceConfidentialInstanceConfigArgs' confidential_instance_config: A set of Compute Engine Confidential VM instance options.
                Structure is documented below.
@@ -494,6 +643,8 @@ class WorkstationConfigHostGceInstance(dict):
         """
         if accelerators is not None:
             pulumi.set(__self__, "accelerators", accelerators)
+        if boost_configs is not None:
+            pulumi.set(__self__, "boost_configs", boost_configs)
         if boot_disk_size_gb is not None:
             pulumi.set(__self__, "boot_disk_size_gb", boot_disk_size_gb)
         if confidential_instance_config is not None:
@@ -526,6 +677,15 @@ class WorkstationConfigHostGceInstance(dict):
         """
         return pulumi.get(self, "accelerators")
 
+    @property
+    @pulumi.getter(name="boostConfigs")
+    def boost_configs(self) -> Optional[Sequence['outputs.WorkstationConfigHostGceInstanceBoostConfig']]:
+        """
+        A list of the boost configurations that workstations created using this workstation configuration are allowed to use.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "boost_configs")
+
     @property
     @pulumi.getter(name="bootDiskSizeGb")
     def boot_disk_size_gb(self) -> Optional[int]:
@@ -647,6 +807,96 @@ class WorkstationConfigHostGceInstanceAccelerator(dict):
         return pulumi.get(self, "type")
 
 
+@pulumi.output_type
+class WorkstationConfigHostGceInstanceBoostConfig(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "machineType":
+            suggest = "machine_type"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in WorkstationConfigHostGceInstanceBoostConfig. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        WorkstationConfigHostGceInstanceBoostConfig.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        WorkstationConfigHostGceInstanceBoostConfig.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 id: str,
+                 accelerators: Optional[Sequence['outputs.WorkstationConfigHostGceInstanceBoostConfigAccelerator']] = None,
+                 machine_type: Optional[str] = None):
+        """
+        :param str id: The id to be used for the boost config.
+        :param Sequence['WorkstationConfigHostGceInstanceBoostConfigAcceleratorArgs'] accelerators: An accelerator card attached to the boost instance.
+               Structure is documented below.
+        :param str machine_type: The type of machine that boosted VM instances will use—for example, e2-standard-4. For more information about machine types that Cloud Workstations supports, see the list of available machine types https://cloud.google.com/workstations/docs/available-machine-types. Defaults to e2-standard-4.
+        """
+        pulumi.set(__self__, "id", id)
+        if accelerators is not None:
+            pulumi.set(__self__, "accelerators", accelerators)
+        if machine_type is not None:
+            pulumi.set(__self__, "machine_type", machine_type)
+
+    @property
+    @pulumi.getter
+    def id(self) -> str:
+        """
+        The id to be used for the boost config.
+        """
+        return pulumi.get(self, "id")
+
+    @property
+    @pulumi.getter
+    def accelerators(self) -> Optional[Sequence['outputs.WorkstationConfigHostGceInstanceBoostConfigAccelerator']]:
+        """
+        An accelerator card attached to the boost instance.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "accelerators")
+
+    @property
+    @pulumi.getter(name="machineType")
+    def machine_type(self) -> Optional[str]:
+        """
+        The type of machine that boosted VM instances will use—for example, e2-standard-4. For more information about machine types that Cloud Workstations supports, see the list of available machine types https://cloud.google.com/workstations/docs/available-machine-types. Defaults to e2-standard-4.
+        """
+        return pulumi.get(self, "machine_type")
+
+
+@pulumi.output_type
+class WorkstationConfigHostGceInstanceBoostConfigAccelerator(dict):
+    def __init__(__self__, *,
+                 count: int,
+                 type: str):
+        """
+        :param int count: Number of accelerator cards exposed to the instance.
+        :param str type: Type of accelerator resource to attach to the instance, for example, "nvidia-tesla-p100".
+        """
+        pulumi.set(__self__, "count", count)
+        pulumi.set(__self__, "type", type)
+
+    @property
+    @pulumi.getter
+    def count(self) -> int:
+        """
+        Number of accelerator cards exposed to the instance.
+        """
+        return pulumi.get(self, "count")
+
+    @property
+    @pulumi.getter
+    def type(self) -> str:
+        """
+        Type of accelerator resource to attach to the instance, for example, "nvidia-tesla-p100".
+        """
+        return pulumi.get(self, "type")
+
+
 @pulumi.output_type
 class WorkstationConfigHostGceInstanceConfidentialInstanceConfig(dict):
     @staticmethod
@@ -887,13 +1137,16 @@ class WorkstationConfigPersistentDirectoryGcePd(dict):
                  size_gb: Optional[int] = None,
                  source_snapshot: Optional[str] = None):
         """
-        :param str disk_type: The type of the persistent disk for the home directory. Defaults to `pd-standard`.
+        :param str disk_type: Type of the disk to use. Defaults to `"pd-standard"`.
         :param str fs_type: Type of file system that the disk should be formatted with. The workstation image must support this file system type. Must be empty if `sourceSnapshot` is set. Defaults to `ext4`.
         :param str reclaim_policy: Whether the persistent disk should be deleted when the workstation is deleted. Valid values are `DELETE` and `RETAIN`. Defaults to `DELETE`.
                Possible values are: `DELETE`, `RETAIN`.
         :param int size_gb: The GB capacity of a persistent home directory for each workstation created with this configuration. Must be empty if `sourceSnapshot` is set.
                Valid values are `10`, `50`, `100`, `200`, `500`, or `1000`. Defaults to `200`. If less than `200` GB, the `diskType` must be `pd-balanced` or `pd-ssd`.
-        :param str source_snapshot: Name of the snapshot to use as the source for the disk. This can be the snapshot's `self_link`, `id`, or a string in the format of `projects/{project}/global/snapshots/{snapshot}`. If set, `sizeGb` and `fsType` must be empty. Can only be updated if it has an existing value.
+        :param str source_snapshot: Name of the snapshot to use as the source for the disk.
+               Must be empty if `sourceImage` is set.
+               Must be empty if `read_only` is false.
+               Updating `source_snapshot` will update content in the ephemeral directory after the workstation is restarted.
         """
         if disk_type is not None:
             pulumi.set(__self__, "disk_type", disk_type)
@@ -910,7 +1163,7 @@ class WorkstationConfigPersistentDirectoryGcePd(dict):
     @pulumi.getter(name="diskType")
     def disk_type(self) -> Optional[str]:
         """
-        The type of the persistent disk for the home directory. Defaults to `pd-standard`.
+        Type of the disk to use. Defaults to `"pd-standard"`.
         """
         return pulumi.get(self, "disk_type")
 
@@ -944,7 +1197,10 @@ class WorkstationConfigPersistentDirectoryGcePd(dict):
     @pulumi.getter(name="sourceSnapshot")
     def source_snapshot(self) -> Optional[str]:
         """
-        Name of the snapshot to use as the source for the disk. This can be the snapshot's `self_link`, `id`, or a string in the format of `projects/{project}/global/snapshots/{snapshot}`. If set, `sizeGb` and `fsType` must be empty. Can only be updated if it has an existing value.
+        Name of the snapshot to use as the source for the disk.
+        Must be empty if `sourceImage` is set.
+        Must be empty if `read_only` is false.
+        Updating `source_snapshot` will update content in the ephemeral directory after the workstation is restarted.
         """
         return pulumi.get(self, "source_snapshot")
 

pulumi_gcp/workstations/workstation_config.py

@@ -25,6 +25,7 @@ class WorkstationConfigArgs:
                  display_name: Optional[pulumi.Input[str]] = None,
                  enable_audit_agent: Optional[pulumi.Input[bool]] = None,
                  encryption_key: Optional[pulumi.Input['WorkstationConfigEncryptionKeyArgs']] = None,
+                 ephemeral_directories: Optional[pulumi.Input[Sequence[pulumi.Input['WorkstationConfigEphemeralDirectoryArgs']]]] = None,
                  host: Optional[pulumi.Input['WorkstationConfigHostArgs']] = None,
                  idle_timeout: Optional[pulumi.Input[str]] = None,
                  labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
@@ -54,6 +55,8 @@ class WorkstationConfigArgs:
                If the customer-managed encryption key is rotated, when the workstation instance is stopped, the system attempts to recreate the persistent disk with the new version of the key. Be sure to keep older versions of the key until the persistent disk is recreated. Otherwise, data on the persistent disk will be lost.
                If the encryption key is revoked, the workstation session will automatically be stopped within 7 hours.
                Structure is documented below.
+        :param pulumi.Input[Sequence[pulumi.Input['WorkstationConfigEphemeralDirectoryArgs']]] ephemeral_directories: Ephemeral directories which won't persist across workstation sessions.
+               Structure is documented below.
         :param pulumi.Input['WorkstationConfigHostArgs'] host: Runtime host for a workstation.
                Structure is documented below.
         :param pulumi.Input[str] idle_timeout: How long to wait before automatically stopping an instance that hasn't recently received any user traffic. A value of 0 indicates that this instance should never time out from idleness. Defaults to 20 minutes.
@@ -87,6 +90,8 @@ class WorkstationConfigArgs:
             pulumi.set(__self__, "enable_audit_agent", enable_audit_agent)
         if encryption_key is not None:
             pulumi.set(__self__, "encryption_key", encryption_key)
+        if ephemeral_directories is not None:
+            pulumi.set(__self__, "ephemeral_directories", ephemeral_directories)
         if host is not None:
             pulumi.set(__self__, "host", host)
         if idle_timeout is not None:
@@ -222,6 +227,19 @@ class WorkstationConfigArgs:
     def encryption_key(self, value: Optional[pulumi.Input['WorkstationConfigEncryptionKeyArgs']]):
         pulumi.set(self, "encryption_key", value)
 
+    @property
+    @pulumi.getter(name="ephemeralDirectories")
+    def ephemeral_directories(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['WorkstationConfigEphemeralDirectoryArgs']]]]:
+        """
+        Ephemeral directories which won't persist across workstation sessions.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "ephemeral_directories")
+
+    @ephemeral_directories.setter
+    def ephemeral_directories(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['WorkstationConfigEphemeralDirectoryArgs']]]]):
+        pulumi.set(self, "ephemeral_directories", value)
+
     @property
     @pulumi.getter
     def host(self) -> Optional[pulumi.Input['WorkstationConfigHostArgs']]:
@@ -342,6 +360,7 @@ class _WorkstationConfigState:
                  effective_labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                  enable_audit_agent: Optional[pulumi.Input[bool]] = None,
                  encryption_key: Optional[pulumi.Input['WorkstationConfigEncryptionKeyArgs']] = None,
+                 ephemeral_directories: Optional[pulumi.Input[Sequence[pulumi.Input['WorkstationConfigEphemeralDirectoryArgs']]]] = None,
                  etag: Optional[pulumi.Input[str]] = None,
                  host: Optional[pulumi.Input['WorkstationConfigHostArgs']] = None,
                  idle_timeout: Optional[pulumi.Input[str]] = None,
@@ -379,6 +398,8 @@ class _WorkstationConfigState:
                If the customer-managed encryption key is rotated, when the workstation instance is stopped, the system attempts to recreate the persistent disk with the new version of the key. Be sure to keep older versions of the key until the persistent disk is recreated. Otherwise, data on the persistent disk will be lost.
                If the encryption key is revoked, the workstation session will automatically be stopped within 7 hours.
                Structure is documented below.
+        :param pulumi.Input[Sequence[pulumi.Input['WorkstationConfigEphemeralDirectoryArgs']]] ephemeral_directories: Ephemeral directories which won't persist across workstation sessions.
+               Structure is documented below.
         :param pulumi.Input[str] etag: Checksum computed by the server.
                May be sent on update and delete requests to ensure that the client has an up-to-date value before proceeding.
         :param pulumi.Input['WorkstationConfigHostArgs'] host: Runtime host for a workstation.
@@ -431,6 +452,8 @@ class _WorkstationConfigState:
             pulumi.set(__self__, "enable_audit_agent", enable_audit_agent)
         if encryption_key is not None:
             pulumi.set(__self__, "encryption_key", encryption_key)
+        if ephemeral_directories is not None:
+            pulumi.set(__self__, "ephemeral_directories", ephemeral_directories)
         if etag is not None:
             pulumi.set(__self__, "etag", etag)
         if host is not None:
@@ -603,6 +626,19 @@ class _WorkstationConfigState:
     def encryption_key(self, value: Optional[pulumi.Input['WorkstationConfigEncryptionKeyArgs']]):
         pulumi.set(self, "encryption_key", value)
 
+    @property
+    @pulumi.getter(name="ephemeralDirectories")
+    def ephemeral_directories(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['WorkstationConfigEphemeralDirectoryArgs']]]]:
+        """
+        Ephemeral directories which won't persist across workstation sessions.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "ephemeral_directories")
+
+    @ephemeral_directories.setter
+    def ephemeral_directories(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['WorkstationConfigEphemeralDirectoryArgs']]]]):
+        pulumi.set(self, "ephemeral_directories", value)
+
     @property
     @pulumi.getter
     def etag(self) -> Optional[pulumi.Input[str]]:
@@ -809,6 +845,7 @@ class WorkstationConfig(pulumi.CustomResource):
                  display_name: Optional[pulumi.Input[str]] = None,
                  enable_audit_agent: Optional[pulumi.Input[bool]] = None,
                  encryption_key: Optional[pulumi.Input[pulumi.InputType['WorkstationConfigEncryptionKeyArgs']]] = None,
+                 ephemeral_directories: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['WorkstationConfigEphemeralDirectoryArgs']]]]] = None,
                  host: Optional[pulumi.Input[pulumi.InputType['WorkstationConfigHostArgs']]] = None,
                  idle_timeout: Optional[pulumi.Input[str]] = None,
                  labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
@@ -1103,6 +1140,59 @@ class WorkstationConfig(pulumi.CustomResource):
             ))
         ```
         <!--End PulumiCodeChooser -->
+        ### Workstation Config Boost
+
+        <!--Start PulumiCodeChooser -->
+        ```python
+        import pulumi
+        import pulumi_gcp as gcp
+
+        default = gcp.compute.Network("default",
+            name="workstation-cluster",
+            auto_create_subnetworks=False)
+        default_subnetwork = gcp.compute.Subnetwork("default",
+            name="workstation-cluster",
+            ip_cidr_range="10.0.0.0/24",
+            region="us-central1",
+            network=default.name)
+        default_workstation_cluster = gcp.workstations.WorkstationCluster("default",
+            workstation_cluster_id="workstation-cluster",
+            network=default.id,
+            subnetwork=default_subnetwork.id,
+            location="us-central1",
+            labels={
+                "label": "key",
+            },
+            annotations={
+                "label-one": "value-one",
+            })
+        default_workstation_config = gcp.workstations.WorkstationConfig("default",
+            workstation_config_id="workstation-config",
+            workstation_cluster_id=default_workstation_cluster.workstation_cluster_id,
+            location="us-central1",
+            host=gcp.workstations.WorkstationConfigHostArgs(
+                gce_instance=gcp.workstations.WorkstationConfigHostGceInstanceArgs(
+                    machine_type="e2-standard-4",
+                    boot_disk_size_gb=35,
+                    disable_public_ip_addresses=True,
+                    boost_configs=[
+                        gcp.workstations.WorkstationConfigHostGceInstanceBoostConfigArgs(
+                            id="boost-1",
+                            machine_type="n1-standard-2",
+                            accelerators=[gcp.workstations.WorkstationConfigHostGceInstanceBoostConfigAcceleratorArgs(
+                                type="nvidia-tesla-t4",
+                                count=1,
+                            )],
+                        ),
+                        gcp.workstations.WorkstationConfigHostGceInstanceBoostConfigArgs(
+                            id="boost-1",
+                            machine_type="e2-standard-2",
+                        ),
+                    ],
+                ),
+            ))
+        ```
+        <!--End PulumiCodeChooser -->
         ### Workstation Config Encryption Key
 
         <!--Start PulumiCodeChooser -->
@@ -1199,6 +1289,8 @@ class WorkstationConfig(pulumi.CustomResource):
                If the customer-managed encryption key is rotated, when the workstation instance is stopped, the system attempts to recreate the persistent disk with the new version of the key. Be sure to keep older versions of the key until the persistent disk is recreated. Otherwise, data on the persistent disk will be lost.
                If the encryption key is revoked, the workstation session will automatically be stopped within 7 hours.
                Structure is documented below.
+        :param pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['WorkstationConfigEphemeralDirectoryArgs']]]] ephemeral_directories: Ephemeral directories which won't persist across workstation sessions.
+               Structure is documented below.
         :param pulumi.Input[pulumi.InputType['WorkstationConfigHostArgs']] host: Runtime host for a workstation.
                Structure is documented below.
         :param pulumi.Input[str] idle_timeout: How long to wait before automatically stopping an instance that hasn't recently received any user traffic. A value of 0 indicates that this instance should never time out from idleness. Defaults to 20 minutes.
@@ -1511,6 +1603,59 @@ class WorkstationConfig(pulumi.CustomResource):
             ))
         ```
         <!--End PulumiCodeChooser -->
+        ### Workstation Config Boost
+
+        <!--Start PulumiCodeChooser -->
+        ```python
+        import pulumi
+        import pulumi_gcp as gcp
+
+        default = gcp.compute.Network("default",
+            name="workstation-cluster",
+            auto_create_subnetworks=False)
+        default_subnetwork = gcp.compute.Subnetwork("default",
+            name="workstation-cluster",
+            ip_cidr_range="10.0.0.0/24",
+            region="us-central1",
+            network=default.name)
+        default_workstation_cluster = gcp.workstations.WorkstationCluster("default",
+            workstation_cluster_id="workstation-cluster",
+            network=default.id,
+            subnetwork=default_subnetwork.id,
+            location="us-central1",
+            labels={
+                "label": "key",
+            },
+            annotations={
+                "label-one": "value-one",
+            })
+        default_workstation_config = gcp.workstations.WorkstationConfig("default",
+            workstation_config_id="workstation-config",
+            workstation_cluster_id=default_workstation_cluster.workstation_cluster_id,
+            location="us-central1",
+            host=gcp.workstations.WorkstationConfigHostArgs(
+                gce_instance=gcp.workstations.WorkstationConfigHostGceInstanceArgs(
+                    machine_type="e2-standard-4",
+                    boot_disk_size_gb=35,
+                    disable_public_ip_addresses=True,
+                    boost_configs=[
+                        gcp.workstations.WorkstationConfigHostGceInstanceBoostConfigArgs(
+                            id="boost-1",
+                            machine_type="n1-standard-2",
+                            accelerators=[gcp.workstations.WorkstationConfigHostGceInstanceBoostConfigAcceleratorArgs(
+                                type="nvidia-tesla-t4",
+                                count=1,
+                            )],
+                        ),
+                        gcp.workstations.WorkstationConfigHostGceInstanceBoostConfigArgs(
+                            id="boost-1",
+                            machine_type="e2-standard-2",
+                        ),
+                    ],
+                ),
+            ))
+        ```
+        <!--End PulumiCodeChooser -->
         ### Workstation Config Encryption Key
 
         <!--Start PulumiCodeChooser -->
@@ -1613,6 +1758,7 @@ class WorkstationConfig(pulumi.CustomResource):
                  display_name: Optional[pulumi.Input[str]] = None,
                  enable_audit_agent: Optional[pulumi.Input[bool]] = None,
                  encryption_key: Optional[pulumi.Input[pulumi.InputType['WorkstationConfigEncryptionKeyArgs']]] = None,
+                 ephemeral_directories: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['WorkstationConfigEphemeralDirectoryArgs']]]]] = None,
                  host: Optional[pulumi.Input[pulumi.InputType['WorkstationConfigHostArgs']]] = None,
                  idle_timeout: Optional[pulumi.Input[str]] = None,
                  labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
@@ -1639,6 +1785,7 @@ class WorkstationConfig(pulumi.CustomResource):
             __props__.__dict__["display_name"] = display_name
             __props__.__dict__["enable_audit_agent"] = enable_audit_agent
             __props__.__dict__["encryption_key"] = encryption_key
+            __props__.__dict__["ephemeral_directories"] = ephemeral_directories
             __props__.__dict__["host"] = host
             __props__.__dict__["idle_timeout"] = idle_timeout
             __props__.__dict__["labels"] = labels
@@ -1688,6 +1835,7 @@ class WorkstationConfig(pulumi.CustomResource):
             effective_labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
             enable_audit_agent: Optional[pulumi.Input[bool]] = None,
             encryption_key: Optional[pulumi.Input[pulumi.InputType['WorkstationConfigEncryptionKeyArgs']]] = None,
+            ephemeral_directories: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['WorkstationConfigEphemeralDirectoryArgs']]]]] = None,
             etag: Optional[pulumi.Input[str]] = None,
             host: Optional[pulumi.Input[pulumi.InputType['WorkstationConfigHostArgs']]] = None,
             idle_timeout: Optional[pulumi.Input[str]] = None,
@@ -1730,6 +1878,8 @@ class WorkstationConfig(pulumi.CustomResource):
                If the customer-managed encryption key is rotated, when the workstation instance is stopped, the system attempts to recreate the persistent disk with the new version of the key. Be sure to keep older versions of the key until the persistent disk is recreated. Otherwise, data on the persistent disk will be lost.
                If the encryption key is revoked, the workstation session will automatically be stopped within 7 hours.
                Structure is documented below.
+        :param pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['WorkstationConfigEphemeralDirectoryArgs']]]] ephemeral_directories: Ephemeral directories which won't persist across workstation sessions.
+               Structure is documented below.
         :param pulumi.Input[str] etag: Checksum computed by the server.
                May be sent on update and delete requests to ensure that the client has an up-to-date value before proceeding.
         :param pulumi.Input[pulumi.InputType['WorkstationConfigHostArgs']] host: Runtime host for a workstation.
@@ -1775,6 +1925,7 @@ class WorkstationConfig(pulumi.CustomResource):
         __props__.__dict__["effective_labels"] = effective_labels
         __props__.__dict__["enable_audit_agent"] = enable_audit_agent
         __props__.__dict__["encryption_key"] = encryption_key
+        __props__.__dict__["ephemeral_directories"] = ephemeral_directories
         __props__.__dict__["etag"] = etag
         __props__.__dict__["host"] = host
         __props__.__dict__["idle_timeout"] = idle_timeout
@@ -1889,6 +2040,15 @@ class WorkstationConfig(pulumi.CustomResource):
         """
         return pulumi.get(self, "encryption_key")
 
+    @property
+    @pulumi.getter(name="ephemeralDirectories")
+    def ephemeral_directories(self) -> pulumi.Output[Sequence['outputs.WorkstationConfigEphemeralDirectory']]:
+        """
+        Ephemeral directories which won't persist across workstation sessions.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "ephemeral_directories")
+
     @property
     @pulumi.getter
     def etag(self) -> pulumi.Output[str]:

{pulumi_gcp-7.15.0a1711038061.dist-info → pulumi_gcp-7.16.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pulumi_gcp
-Version: 7.15.0a1711038061
+Version: 7.16.0
 Summary: A Pulumi package for creating and managing Google Cloud Platform resources.
 License: Apache-2.0
 Project-URL: Homepage, https://pulumi.io