pulumi-gcp 8.18.0a1738650987__py3-none-any.whl → 8.19.0__py3-none-any.whl

pulumi_gcp/container/outputs.py

@@ -144,6 +144,7 @@ __all__ = [
     'ClusterMonitoringConfig',
     'ClusterMonitoringConfigAdvancedDatapathObservabilityConfig',
     'ClusterMonitoringConfigManagedPrometheus',
+    'ClusterMonitoringConfigManagedPrometheusAutoMonitoringConfig',
     'ClusterNetworkPolicy',
     'ClusterNodeConfig',
     'ClusterNodeConfigAdvancedMachineFeatures',
@@ -346,6 +347,7 @@ __all__ = [
     'GetClusterMonitoringConfigResult',
     'GetClusterMonitoringConfigAdvancedDatapathObservabilityConfigResult',
     'GetClusterMonitoringConfigManagedPrometheusResult',
+    'GetClusterMonitoringConfigManagedPrometheusAutoMonitoringConfigResult',
     'GetClusterNetworkPolicyResult',
     'GetClusterNodeConfigResult',
     'GetClusterNodeConfigAdvancedMachineFeatureResult',
@@ -5287,22 +5289,29 @@ class ClusterClusterAutoscalingResourceLimit(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
+                 maximum: int,
                  resource_type: str,
-                 maximum: Optional[int] = None,
                  minimum: Optional[int] = None):
         """
+        :param int maximum: Maximum amount of the resource in the cluster.
         :param str resource_type: The type of the resource. For example, `cpu` and
                `memory`.  See the [guide to using Node Auto-Provisioning](https://cloud.google.com/kubernetes-engine/docs/how-to/node-auto-provisioning)
                for a list of types.
-        :param int maximum: Maximum amount of the resource in the cluster.
         :param int minimum: Minimum amount of the resource in the cluster.
         """
+        pulumi.set(__self__, "maximum", maximum)
         pulumi.set(__self__, "resource_type", resource_type)
-        if maximum is not None:
-            pulumi.set(__self__, "maximum", maximum)
         if minimum is not None:
             pulumi.set(__self__, "minimum", minimum)
 
+    @property
+    @pulumi.getter
+    def maximum(self) -> int:
+        """
+        Maximum amount of the resource in the cluster.
+        """
+        return pulumi.get(self, "maximum")
+
     @property
     @pulumi.getter(name="resourceType")
     def resource_type(self) -> str:
@@ -5313,14 +5322,6 @@ class ClusterClusterAutoscalingResourceLimit(dict):
         """
         return pulumi.get(self, "resource_type")
 
-    @property
-    @pulumi.getter
-    def maximum(self) -> Optional[int]:
-        """
-        Maximum amount of the resource in the cluster.
-        """
-        return pulumi.get(self, "maximum")
-
     @property
     @pulumi.getter
     def minimum(self) -> Optional[int]:
@@ -6830,12 +6831,33 @@ class ClusterMonitoringConfigAdvancedDatapathObservabilityConfig(dict):
 
 @pulumi.output_type
 class ClusterMonitoringConfigManagedPrometheus(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "autoMonitoringConfig":
+            suggest = "auto_monitoring_config"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ClusterMonitoringConfigManagedPrometheus. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ClusterMonitoringConfigManagedPrometheus.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ClusterMonitoringConfigManagedPrometheus.__key_warning(key)
+        return super().get(key, default)
+
     def __init__(__self__, *,
-                 enabled: bool):
+                 enabled: bool,
+                 auto_monitoring_config: Optional['outputs.ClusterMonitoringConfigManagedPrometheusAutoMonitoringConfig'] = None):
         """
         :param bool enabled: Whether or not the managed collection is enabled.
+        :param 'ClusterMonitoringConfigManagedPrometheusAutoMonitoringConfigArgs' auto_monitoring_config: Configuration options for GKE Auto-Monitoring.
         """
         pulumi.set(__self__, "enabled", enabled)
+        if auto_monitoring_config is not None:
+            pulumi.set(__self__, "auto_monitoring_config", auto_monitoring_config)
 
     @property
     @pulumi.getter
@@ -6845,6 +6867,32 @@ class ClusterMonitoringConfigManagedPrometheus(dict):
         """
         return pulumi.get(self, "enabled")
 
+    @property
+    @pulumi.getter(name="autoMonitoringConfig")
+    def auto_monitoring_config(self) -> Optional['outputs.ClusterMonitoringConfigManagedPrometheusAutoMonitoringConfig']:
+        """
+        Configuration options for GKE Auto-Monitoring.
+        """
+        return pulumi.get(self, "auto_monitoring_config")
+
+
+@pulumi.output_type
+class ClusterMonitoringConfigManagedPrometheusAutoMonitoringConfig(dict):
+    def __init__(__self__, *,
+                 scope: str):
+        """
+        :param str scope: Whether or not to enable GKE Auto-Monitoring. Supported values include: `ALL`, `NONE`.
+        """
+        pulumi.set(__self__, "scope", scope)
+
+    @property
+    @pulumi.getter
+    def scope(self) -> str:
+        """
+        Whether or not to enable GKE Auto-Monitoring. Supported values include: `ALL`, `NONE`.
+        """
+        return pulumi.get(self, "scope")
+
 
 @pulumi.output_type
 class ClusterNetworkPolicy(dict):
@@ -6925,6 +6973,8 @@ class ClusterNodeConfig(dict):
             suggest = "logging_variant"
         elif key == "machineType":
             suggest = "machine_type"
+        elif key == "maxRunDuration":
+            suggest = "max_run_duration"
         elif key == "minCpuPlatform":
             suggest = "min_cpu_platform"
         elif key == "nodeGroup":
@@ -6988,6 +7038,7 @@ class ClusterNodeConfig(dict):
                  local_ssd_encryption_mode: Optional[str] = None,
                  logging_variant: Optional[str] = None,
                  machine_type: Optional[str] = None,
+                 max_run_duration: Optional[str] = None,
                  metadata: Optional[Mapping[str, str]] = None,
                  min_cpu_platform: Optional[str] = None,
                  node_group: Optional[str] = None,
@@ -7065,6 +7116,7 @@ class ClusterNodeConfig(dict):
         :param str machine_type: The name of a Google Compute Engine machine type.
                Defaults to `e2-medium`. To create a custom machine type, value should be set as specified
                [here](https://cloud.google.com/compute/docs/reference/latest/instances#machineType).
+        :param str max_run_duration: The runtime of each node in the node pool in seconds, terminated by 's'. Example: "3600s".
         :param Mapping[str, str] metadata: The metadata key/value pairs assigned to instances in
                the cluster. From GKE `1.12` onwards, `disable-legacy-endpoints` is set to
                `true` by the API; if `metadata` is set but that default value is not
@@ -7159,6 +7211,8 @@ class ClusterNodeConfig(dict):
             pulumi.set(__self__, "logging_variant", logging_variant)
         if machine_type is not None:
             pulumi.set(__self__, "machine_type", machine_type)
+        if max_run_duration is not None:
+            pulumi.set(__self__, "max_run_duration", max_run_duration)
         if metadata is not None:
             pulumi.set(__self__, "metadata", metadata)
         if min_cpu_platform is not None:
@@ -7422,6 +7476,14 @@ class ClusterNodeConfig(dict):
         """
         return pulumi.get(self, "machine_type")
 
+    @property
+    @pulumi.getter(name="maxRunDuration")
+    def max_run_duration(self) -> Optional[str]:
+        """
+        The runtime of each node in the node pool in seconds, terminated by 's'. Example: "3600s".
+        """
+        return pulumi.get(self, "max_run_duration")
+
     @property
     @pulumi.getter
     def metadata(self) -> Optional[Mapping[str, str]]:
@@ -10085,6 +10147,8 @@ class ClusterNodePoolNodeConfig(dict):
             suggest = "logging_variant"
         elif key == "machineType":
             suggest = "machine_type"
+        elif key == "maxRunDuration":
+            suggest = "max_run_duration"
         elif key == "minCpuPlatform":
             suggest = "min_cpu_platform"
         elif key == "nodeGroup":
@@ -10148,6 +10212,7 @@ class ClusterNodePoolNodeConfig(dict):
                  local_ssd_encryption_mode: Optional[str] = None,
                  logging_variant: Optional[str] = None,
                  machine_type: Optional[str] = None,
+                 max_run_duration: Optional[str] = None,
                  metadata: Optional[Mapping[str, str]] = None,
                  min_cpu_platform: Optional[str] = None,
                  node_group: Optional[str] = None,
@@ -10225,6 +10290,7 @@ class ClusterNodePoolNodeConfig(dict):
         :param str machine_type: The name of a Google Compute Engine machine type.
                Defaults to `e2-medium`. To create a custom machine type, value should be set as specified
                [here](https://cloud.google.com/compute/docs/reference/latest/instances#machineType).
+        :param str max_run_duration: The runtime of each node in the node pool in seconds, terminated by 's'. Example: "3600s".
         :param Mapping[str, str] metadata: The metadata key/value pairs assigned to instances in
                the cluster. From GKE `1.12` onwards, `disable-legacy-endpoints` is set to
                `true` by the API; if `metadata` is set but that default value is not
@@ -10319,6 +10385,8 @@ class ClusterNodePoolNodeConfig(dict):
             pulumi.set(__self__, "logging_variant", logging_variant)
         if machine_type is not None:
             pulumi.set(__self__, "machine_type", machine_type)
+        if max_run_duration is not None:
+            pulumi.set(__self__, "max_run_duration", max_run_duration)
         if metadata is not None:
             pulumi.set(__self__, "metadata", metadata)
         if min_cpu_platform is not None:
@@ -10582,6 +10650,14 @@ class ClusterNodePoolNodeConfig(dict):
         """
         return pulumi.get(self, "machine_type")
 
+    @property
+    @pulumi.getter(name="maxRunDuration")
+    def max_run_duration(self) -> Optional[str]:
+        """
+        The runtime of each node in the node pool in seconds, terminated by 's'. Example: "3600s".
+        """
+        return pulumi.get(self, "max_run_duration")
+
     @property
     @pulumi.getter
     def metadata(self) -> Optional[Mapping[str, str]]:
@@ -13668,6 +13744,8 @@ class NodePoolNodeConfig(dict):
             suggest = "logging_variant"
         elif key == "machineType":
             suggest = "machine_type"
+        elif key == "maxRunDuration":
+            suggest = "max_run_duration"
         elif key == "minCpuPlatform":
             suggest = "min_cpu_platform"
         elif key == "nodeGroup":
@@ -13731,6 +13809,7 @@ class NodePoolNodeConfig(dict):
                  local_ssd_encryption_mode: Optional[str] = None,
                  logging_variant: Optional[str] = None,
                  machine_type: Optional[str] = None,
+                 max_run_duration: Optional[str] = None,
                  metadata: Optional[Mapping[str, str]] = None,
                  min_cpu_platform: Optional[str] = None,
                  node_group: Optional[str] = None,
@@ -13774,6 +13853,7 @@ class NodePoolNodeConfig(dict):
         :param str local_ssd_encryption_mode: LocalSsdEncryptionMode specified the method used for encrypting the local SSDs attached to the node.
         :param str logging_variant: Type of logging agent that is used as the default value for node pools in the cluster. Valid values include DEFAULT and MAX_THROUGHPUT.
         :param str machine_type: The name of a Google Compute Engine machine type.
+        :param str max_run_duration: The runtime of each node in the node pool in seconds, terminated by 's'. Example: "3600s".
         :param Mapping[str, str] metadata: The metadata key/value pairs assigned to instances in the cluster.
         :param str min_cpu_platform: Minimum CPU platform to be used by this instance. The instance may be scheduled on the specified or newer CPU platform.
         :param str node_group: Setting this field will assign instances of this pool to run on the specified node group. This is useful for running workloads on sole tenant nodes.
@@ -13844,6 +13924,8 @@ class NodePoolNodeConfig(dict):
             pulumi.set(__self__, "logging_variant", logging_variant)
         if machine_type is not None:
             pulumi.set(__self__, "machine_type", machine_type)
+        if max_run_duration is not None:
+            pulumi.set(__self__, "max_run_duration", max_run_duration)
         if metadata is not None:
             pulumi.set(__self__, "metadata", metadata)
         if min_cpu_platform is not None:
@@ -14073,6 +14155,14 @@ class NodePoolNodeConfig(dict):
         """
         return pulumi.get(self, "machine_type")
 
+    @property
+    @pulumi.getter(name="maxRunDuration")
+    def max_run_duration(self) -> Optional[str]:
+        """
+        The runtime of each node in the node pool in seconds, terminated by 's'. Example: "3600s".
+        """
+        return pulumi.get(self, "max_run_duration")
+
     @property
     @pulumi.getter
     def metadata(self) -> Optional[Mapping[str, str]]:
@@ -17454,12 +17544,23 @@ class GetClusterMonitoringConfigAdvancedDatapathObservabilityConfigResult(dict):
 @pulumi.output_type
 class GetClusterMonitoringConfigManagedPrometheusResult(dict):
     def __init__(__self__, *,
+                 auto_monitoring_configs: Sequence['outputs.GetClusterMonitoringConfigManagedPrometheusAutoMonitoringConfigResult'],
                  enabled: bool):
         """
+        :param Sequence['GetClusterMonitoringConfigManagedPrometheusAutoMonitoringConfigArgs'] auto_monitoring_configs: Configuration for GKE Workload Auto-Monitoring.
         :param bool enabled: Whether or not the managed collection is enabled.
         """
+        pulumi.set(__self__, "auto_monitoring_configs", auto_monitoring_configs)
         pulumi.set(__self__, "enabled", enabled)
 
+    @property
+    @pulumi.getter(name="autoMonitoringConfigs")
+    def auto_monitoring_configs(self) -> Sequence['outputs.GetClusterMonitoringConfigManagedPrometheusAutoMonitoringConfigResult']:
+        """
+        Configuration for GKE Workload Auto-Monitoring.
+        """
+        return pulumi.get(self, "auto_monitoring_configs")
+
     @property
     @pulumi.getter
     def enabled(self) -> bool:
@@ -17469,6 +17570,24 @@ class GetClusterMonitoringConfigManagedPrometheusResult(dict):
         return pulumi.get(self, "enabled")
 
 
+@pulumi.output_type
+class GetClusterMonitoringConfigManagedPrometheusAutoMonitoringConfigResult(dict):
+    def __init__(__self__, *,
+                 scope: str):
+        """
+        :param str scope: The scope of auto-monitoring.
+        """
+        pulumi.set(__self__, "scope", scope)
+
+    @property
+    @pulumi.getter
+    def scope(self) -> str:
+        """
+        The scope of auto-monitoring.
+        """
+        return pulumi.get(self, "scope")
+
+
 @pulumi.output_type
 class GetClusterNetworkPolicyResult(dict):
     def __init__(__self__, *,
@@ -17525,6 +17644,7 @@ class GetClusterNodeConfigResult(dict):
                  local_ssd_encryption_mode: str,
                  logging_variant: str,
                  machine_type: str,
+                 max_run_duration: str,
                  metadata: Mapping[str, str],
                  min_cpu_platform: str,
                  node_group: str,
@@ -17568,6 +17688,7 @@ class GetClusterNodeConfigResult(dict):
         :param str local_ssd_encryption_mode: LocalSsdEncryptionMode specified the method used for encrypting the local SSDs attached to the node.
         :param str logging_variant: Type of logging agent that is used as the default value for node pools in the cluster. Valid values include DEFAULT and MAX_THROUGHPUT.
         :param str machine_type: The name of a Google Compute Engine machine type.
+        :param str max_run_duration: The runtime of each node in the node pool in seconds, terminated by 's'. Example: "3600s".
         :param Mapping[str, str] metadata: The metadata key/value pairs assigned to instances in the cluster.
         :param str min_cpu_platform: Minimum CPU platform to be used by this instance. The instance may be scheduled on the specified or newer CPU platform.
         :param str node_group: Setting this field will assign instances of this pool to run on the specified node group. This is useful for running workloads on sole tenant nodes.
@@ -17611,6 +17732,7 @@ class GetClusterNodeConfigResult(dict):
         pulumi.set(__self__, "local_ssd_encryption_mode", local_ssd_encryption_mode)
         pulumi.set(__self__, "logging_variant", logging_variant)
         pulumi.set(__self__, "machine_type", machine_type)
+        pulumi.set(__self__, "max_run_duration", max_run_duration)
         pulumi.set(__self__, "metadata", metadata)
         pulumi.set(__self__, "min_cpu_platform", min_cpu_platform)
         pulumi.set(__self__, "node_group", node_group)
@@ -17822,6 +17944,14 @@ class GetClusterNodeConfigResult(dict):
         """
         return pulumi.get(self, "machine_type")
 
+    @property
+    @pulumi.getter(name="maxRunDuration")
+    def max_run_duration(self) -> str:
+        """
+        The runtime of each node in the node pool in seconds, terminated by 's'. Example: "3600s".
+        """
+        return pulumi.get(self, "max_run_duration")
+
     @property
     @pulumi.getter
     def metadata(self) -> Mapping[str, str]:
@@ -19523,6 +19653,7 @@ class GetClusterNodePoolNodeConfigResult(dict):
                  local_ssd_encryption_mode: str,
                  logging_variant: str,
                  machine_type: str,
+                 max_run_duration: str,
                  metadata: Mapping[str, str],
                  min_cpu_platform: str,
                  node_group: str,
@@ -19566,6 +19697,7 @@ class GetClusterNodePoolNodeConfigResult(dict):
         :param str local_ssd_encryption_mode: LocalSsdEncryptionMode specified the method used for encrypting the local SSDs attached to the node.
         :param str logging_variant: Type of logging agent that is used as the default value for node pools in the cluster. Valid values include DEFAULT and MAX_THROUGHPUT.
         :param str machine_type: The name of a Google Compute Engine machine type.
+        :param str max_run_duration: The runtime of each node in the node pool in seconds, terminated by 's'. Example: "3600s".
         :param Mapping[str, str] metadata: The metadata key/value pairs assigned to instances in the cluster.
         :param str min_cpu_platform: Minimum CPU platform to be used by this instance. The instance may be scheduled on the specified or newer CPU platform.
         :param str node_group: Setting this field will assign instances of this pool to run on the specified node group. This is useful for running workloads on sole tenant nodes.
@@ -19609,6 +19741,7 @@ class GetClusterNodePoolNodeConfigResult(dict):
         pulumi.set(__self__, "local_ssd_encryption_mode", local_ssd_encryption_mode)
         pulumi.set(__self__, "logging_variant", logging_variant)
         pulumi.set(__self__, "machine_type", machine_type)
+        pulumi.set(__self__, "max_run_duration", max_run_duration)
         pulumi.set(__self__, "metadata", metadata)
         pulumi.set(__self__, "min_cpu_platform", min_cpu_platform)
         pulumi.set(__self__, "node_group", node_group)
@@ -19820,6 +19953,14 @@ class GetClusterNodePoolNodeConfigResult(dict):
         """
         return pulumi.get(self, "machine_type")
 
+    @property
+    @pulumi.getter(name="maxRunDuration")
+    def max_run_duration(self) -> str:
+        """
+        The runtime of each node in the node pool in seconds, terminated by 's'. Example: "3600s".
+        """
+        return pulumi.get(self, "max_run_duration")
+
     @property
     @pulumi.getter
     def metadata(self) -> Mapping[str, str]:

pulumi_gcp/dataproc/_inputs.py

@@ -243,6 +243,8 @@ __all__ = [
     'MetastoreServiceScheduledBackupArgsDict',
     'MetastoreServiceTelemetryConfigArgs',
     'MetastoreServiceTelemetryConfigArgsDict',
+    'WorkflowTemplateEncryptionConfigArgs',
+    'WorkflowTemplateEncryptionConfigArgsDict',
     'WorkflowTemplateJobArgs',
     'WorkflowTemplateJobArgsDict',
     'WorkflowTemplateJobHadoopJobArgs',
@@ -10187,6 +10189,38 @@ class MetastoreServiceTelemetryConfigArgs:
         pulumi.set(self, "log_format", value)
 
 
+if not MYPY:
+    class WorkflowTemplateEncryptionConfigArgsDict(TypedDict):
+        kms_key: NotRequired[pulumi.Input[str]]
+        """
+        Optional. The Cloud KMS key name to use for encryption.
+        """
+elif False:
+    WorkflowTemplateEncryptionConfigArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class WorkflowTemplateEncryptionConfigArgs:
+    def __init__(__self__, *,
+                 kms_key: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[str] kms_key: Optional. The Cloud KMS key name to use for encryption.
+        """
+        if kms_key is not None:
+            pulumi.set(__self__, "kms_key", kms_key)
+
+    @property
+    @pulumi.getter(name="kmsKey")
+    def kms_key(self) -> Optional[pulumi.Input[str]]:
+        """
+        Optional. The Cloud KMS key name to use for encryption.
+        """
+        return pulumi.get(self, "kms_key")
+
+    @kms_key.setter
+    def kms_key(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "kms_key", value)
+
+
 if not MYPY:
     class WorkflowTemplateJobArgsDict(TypedDict):
         step_id: pulumi.Input[str]

pulumi_gcp/dataproc/outputs.py

@@ -130,6 +130,7 @@ __all__ = [
     'MetastoreServiceScalingConfigAutoscalingConfigLimitConfig',
     'MetastoreServiceScheduledBackup',
     'MetastoreServiceTelemetryConfig',
+    'WorkflowTemplateEncryptionConfig',
     'WorkflowTemplateJob',
     'WorkflowTemplateJobHadoopJob',
     'WorkflowTemplateJobHadoopJobLoggingConfig',
@@ -8160,6 +8161,42 @@ class MetastoreServiceTelemetryConfig(dict):
         return pulumi.get(self, "log_format")
 
 
+@pulumi.output_type
+class WorkflowTemplateEncryptionConfig(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "kmsKey":
+            suggest = "kms_key"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in WorkflowTemplateEncryptionConfig. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        WorkflowTemplateEncryptionConfig.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        WorkflowTemplateEncryptionConfig.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 kms_key: Optional[str] = None):
+        """
+        :param str kms_key: Optional. The Cloud KMS key name to use for encryption.
+        """
+        if kms_key is not None:
+            pulumi.set(__self__, "kms_key", kms_key)
+
+    @property
+    @pulumi.getter(name="kmsKey")
+    def kms_key(self) -> Optional[str]:
+        """
+        Optional. The Cloud KMS key name to use for encryption.
+        """
+        return pulumi.get(self, "kms_key")
+
+
 @pulumi.output_type
 class WorkflowTemplateJob(dict):
     @staticmethod

pulumi_gcp/dataproc/workflow_template.py

@@ -25,6 +25,7 @@ class WorkflowTemplateArgs:
                  location: pulumi.Input[str],
                  placement: pulumi.Input['WorkflowTemplatePlacementArgs'],
                  dag_timeout: Optional[pulumi.Input[str]] = None,
+                 encryption_config: Optional[pulumi.Input['WorkflowTemplateEncryptionConfigArgs']] = None,
                  labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                  name: Optional[pulumi.Input[str]] = None,
                  parameters: Optional[pulumi.Input[Sequence[pulumi.Input['WorkflowTemplateParameterArgs']]]] = None,
@@ -42,6 +43,7 @@ class WorkflowTemplateArgs:
                on a [managed
                cluster](https://www.terraform.io/dataproc/docs/concepts/workflows/using-workflows#configuring_or_selecting_a_cluster),
                the cluster is deleted.
+        :param pulumi.Input['WorkflowTemplateEncryptionConfigArgs'] encryption_config: Optional. The encryption configuration for the workflow template.
         :param pulumi.Input[Mapping[str, pulumi.Input[str]]] labels: Optional. The labels to associate with this template. These labels will be propagated to all jobs and clusters created
                by the workflow instance. Label **keys** must contain 1 to 63 characters, and must conform to [RFC
                1035](https://www.ietf.org/rfc/rfc1035.txt). Label **values** may be empty, but, if present, must contain 1 to 63
@@ -59,6 +61,8 @@ class WorkflowTemplateArgs:
         pulumi.set(__self__, "placement", placement)
         if dag_timeout is not None:
             pulumi.set(__self__, "dag_timeout", dag_timeout)
+        if encryption_config is not None:
+            pulumi.set(__self__, "encryption_config", encryption_config)
         if labels is not None:
             pulumi.set(__self__, "labels", labels)
         if name is not None:
@@ -127,6 +131,18 @@ class WorkflowTemplateArgs:
     def dag_timeout(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "dag_timeout", value)
 
+    @property
+    @pulumi.getter(name="encryptionConfig")
+    def encryption_config(self) -> Optional[pulumi.Input['WorkflowTemplateEncryptionConfigArgs']]:
+        """
+        Optional. The encryption configuration for the workflow template.
+        """
+        return pulumi.get(self, "encryption_config")
+
+    @encryption_config.setter
+    def encryption_config(self, value: Optional[pulumi.Input['WorkflowTemplateEncryptionConfigArgs']]):
+        pulumi.set(self, "encryption_config", value)
+
     @property
     @pulumi.getter
     def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
@@ -201,6 +217,7 @@ class _WorkflowTemplateState:
                  create_time: Optional[pulumi.Input[str]] = None,
                  dag_timeout: Optional[pulumi.Input[str]] = None,
                  effective_labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
+                 encryption_config: Optional[pulumi.Input['WorkflowTemplateEncryptionConfigArgs']] = None,
                  jobs: Optional[pulumi.Input[Sequence[pulumi.Input['WorkflowTemplateJobArgs']]]] = None,
                  labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                  location: Optional[pulumi.Input[str]] = None,
@@ -221,6 +238,7 @@ class _WorkflowTemplateState:
                on a [managed
                cluster](https://www.terraform.io/dataproc/docs/concepts/workflows/using-workflows#configuring_or_selecting_a_cluster),
                the cluster is deleted.
+        :param pulumi.Input['WorkflowTemplateEncryptionConfigArgs'] encryption_config: Optional. The encryption configuration for the workflow template.
         :param pulumi.Input[Sequence[pulumi.Input['WorkflowTemplateJobArgs']]] jobs: Required. The Directed Acyclic Graph of Jobs to submit.
         :param pulumi.Input[Mapping[str, pulumi.Input[str]]] labels: Optional. The labels to associate with this template. These labels will be propagated to all jobs and clusters created
                by the workflow instance. Label **keys** must contain 1 to 63 characters, and must conform to [RFC
@@ -244,6 +262,8 @@ class _WorkflowTemplateState:
             pulumi.set(__self__, "dag_timeout", dag_timeout)
         if effective_labels is not None:
             pulumi.set(__self__, "effective_labels", effective_labels)
+        if encryption_config is not None:
+            pulumi.set(__self__, "encryption_config", encryption_config)
         if jobs is not None:
             pulumi.set(__self__, "jobs", jobs)
         if labels is not None:
@@ -307,6 +327,18 @@ class _WorkflowTemplateState:
     def effective_labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
         pulumi.set(self, "effective_labels", value)
 
+    @property
+    @pulumi.getter(name="encryptionConfig")
+    def encryption_config(self) -> Optional[pulumi.Input['WorkflowTemplateEncryptionConfigArgs']]:
+        """
+        Optional. The encryption configuration for the workflow template.
+        """
+        return pulumi.get(self, "encryption_config")
+
+    @encryption_config.setter
+    def encryption_config(self, value: Optional[pulumi.Input['WorkflowTemplateEncryptionConfigArgs']]):
+        pulumi.set(self, "encryption_config", value)
+
     @property
     @pulumi.getter
     def jobs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['WorkflowTemplateJobArgs']]]]:
@@ -441,6 +473,7 @@ class WorkflowTemplate(pulumi.CustomResource):
                  resource_name: str,
                  opts: Optional[pulumi.ResourceOptions] = None,
                  dag_timeout: Optional[pulumi.Input[str]] = None,
+                 encryption_config: Optional[pulumi.Input[Union['WorkflowTemplateEncryptionConfigArgs', 'WorkflowTemplateEncryptionConfigArgsDict']]] = None,
                  jobs: Optional[pulumi.Input[Sequence[pulumi.Input[Union['WorkflowTemplateJobArgs', 'WorkflowTemplateJobArgsDict']]]]] = None,
                  labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                  location: Optional[pulumi.Input[str]] = None,
@@ -548,6 +581,7 @@ class WorkflowTemplate(pulumi.CustomResource):
                on a [managed
                cluster](https://www.terraform.io/dataproc/docs/concepts/workflows/using-workflows#configuring_or_selecting_a_cluster),
                the cluster is deleted.
+        :param pulumi.Input[Union['WorkflowTemplateEncryptionConfigArgs', 'WorkflowTemplateEncryptionConfigArgsDict']] encryption_config: Optional. The encryption configuration for the workflow template.
         :param pulumi.Input[Sequence[pulumi.Input[Union['WorkflowTemplateJobArgs', 'WorkflowTemplateJobArgsDict']]]] jobs: Required. The Directed Acyclic Graph of Jobs to submit.
         :param pulumi.Input[Mapping[str, pulumi.Input[str]]] labels: Optional. The labels to associate with this template. These labels will be propagated to all jobs and clusters created
                by the workflow instance. Label **keys** must contain 1 to 63 characters, and must conform to [RFC
@@ -674,6 +708,7 @@ class WorkflowTemplate(pulumi.CustomResource):
                  resource_name: str,
                  opts: Optional[pulumi.ResourceOptions] = None,
                  dag_timeout: Optional[pulumi.Input[str]] = None,
+                 encryption_config: Optional[pulumi.Input[Union['WorkflowTemplateEncryptionConfigArgs', 'WorkflowTemplateEncryptionConfigArgsDict']]] = None,
                  jobs: Optional[pulumi.Input[Sequence[pulumi.Input[Union['WorkflowTemplateJobArgs', 'WorkflowTemplateJobArgsDict']]]]] = None,
                  labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                  location: Optional[pulumi.Input[str]] = None,
@@ -692,6 +727,7 @@ class WorkflowTemplate(pulumi.CustomResource):
             __props__ = WorkflowTemplateArgs.__new__(WorkflowTemplateArgs)
 
             __props__.__dict__["dag_timeout"] = dag_timeout
+            __props__.__dict__["encryption_config"] = encryption_config
             if jobs is None and not opts.urn:
                 raise TypeError("Missing required property 'jobs'")
             __props__.__dict__["jobs"] = jobs
@@ -725,6 +761,7 @@ class WorkflowTemplate(pulumi.CustomResource):
             create_time: Optional[pulumi.Input[str]] = None,
             dag_timeout: Optional[pulumi.Input[str]] = None,
             effective_labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
+            encryption_config: Optional[pulumi.Input[Union['WorkflowTemplateEncryptionConfigArgs', 'WorkflowTemplateEncryptionConfigArgsDict']]] = None,
             jobs: Optional[pulumi.Input[Sequence[pulumi.Input[Union['WorkflowTemplateJobArgs', 'WorkflowTemplateJobArgsDict']]]]] = None,
             labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
             location: Optional[pulumi.Input[str]] = None,
@@ -750,6 +787,7 @@ class WorkflowTemplate(pulumi.CustomResource):
                on a [managed
                cluster](https://www.terraform.io/dataproc/docs/concepts/workflows/using-workflows#configuring_or_selecting_a_cluster),
                the cluster is deleted.
+        :param pulumi.Input[Union['WorkflowTemplateEncryptionConfigArgs', 'WorkflowTemplateEncryptionConfigArgsDict']] encryption_config: Optional. The encryption configuration for the workflow template.
         :param pulumi.Input[Sequence[pulumi.Input[Union['WorkflowTemplateJobArgs', 'WorkflowTemplateJobArgsDict']]]] jobs: Required. The Directed Acyclic Graph of Jobs to submit.
         :param pulumi.Input[Mapping[str, pulumi.Input[str]]] labels: Optional. The labels to associate with this template. These labels will be propagated to all jobs and clusters created
                by the workflow instance. Label **keys** must contain 1 to 63 characters, and must conform to [RFC
@@ -774,6 +812,7 @@ class WorkflowTemplate(pulumi.CustomResource):
         __props__.__dict__["create_time"] = create_time
         __props__.__dict__["dag_timeout"] = dag_timeout
         __props__.__dict__["effective_labels"] = effective_labels
+        __props__.__dict__["encryption_config"] = encryption_config
         __props__.__dict__["jobs"] = jobs
         __props__.__dict__["labels"] = labels
         __props__.__dict__["location"] = location
@@ -813,6 +852,14 @@ class WorkflowTemplate(pulumi.CustomResource):
     def effective_labels(self) -> pulumi.Output[Mapping[str, str]]:
         return pulumi.get(self, "effective_labels")
 
+    @property
+    @pulumi.getter(name="encryptionConfig")
+    def encryption_config(self) -> pulumi.Output[Optional['outputs.WorkflowTemplateEncryptionConfig']]:
+        """
+        Optional. The encryption configuration for the workflow template.
+        """
+        return pulumi.get(self, "encryption_config")
+
     @property
     @pulumi.getter
     def jobs(self) -> pulumi.Output[Sequence['outputs.WorkflowTemplateJob']]: