pulumi-gcp 7.27.0a1718086610__py3-none-any.whl → 7.27.0a1718247696__py3-none-any.whl

pulumi_gcp/netapp/outputs.py

@@ -11,6 +11,7 @@ from .. import _utilities
 from . import outputs
 
 __all__ = [
+    'VolumeBackupConfig',
     'VolumeExportPolicy',
     'VolumeExportPolicyRule',
     'VolumeMountOption',
@@ -24,6 +25,72 @@ __all__ = [
     'VolumeSnapshotPolicyWeeklySchedule',
 ]
 
+@pulumi.output_type
+class VolumeBackupConfig(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "backupPolicies":
+            suggest = "backup_policies"
+        elif key == "backupVault":
+            suggest = "backup_vault"
+        elif key == "scheduledBackupEnabled":
+            suggest = "scheduled_backup_enabled"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in VolumeBackupConfig. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        VolumeBackupConfig.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        VolumeBackupConfig.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 backup_policies: Optional[Sequence[str]] = None,
+                 backup_vault: Optional[str] = None,
+                 scheduled_backup_enabled: Optional[bool] = None):
+        """
+        :param Sequence[str] backup_policies: Specify a single backup policy ID for scheduled backups. Format: `projects/{{projectId}}/locations/{{location}}/backupPolicies/{{backupPolicyName}}`
+        :param str backup_vault: ID of the backup vault to use. A backup vault is reqired to create manual or scheduled backups.
+               Format: `projects/{{projectId}}/locations/{{location}}/backupVaults/{{backupVaultName}}`
+        :param bool scheduled_backup_enabled: When set to true, scheduled backup is enabled on the volume. Omit if no backup_policy is specified.
+        """
+        if backup_policies is not None:
+            pulumi.set(__self__, "backup_policies", backup_policies)
+        if backup_vault is not None:
+            pulumi.set(__self__, "backup_vault", backup_vault)
+        if scheduled_backup_enabled is not None:
+            pulumi.set(__self__, "scheduled_backup_enabled", scheduled_backup_enabled)
+
+    @property
+    @pulumi.getter(name="backupPolicies")
+    def backup_policies(self) -> Optional[Sequence[str]]:
+        """
+        Specify a single backup policy ID for scheduled backups. Format: `projects/{{projectId}}/locations/{{location}}/backupPolicies/{{backupPolicyName}}`
+        """
+        return pulumi.get(self, "backup_policies")
+
+    @property
+    @pulumi.getter(name="backupVault")
+    def backup_vault(self) -> Optional[str]:
+        """
+        ID of the backup vault to use. A backup vault is reqired to create manual or scheduled backups.
+        Format: `projects/{{projectId}}/locations/{{location}}/backupVaults/{{backupVaultName}}`
+        """
+        return pulumi.get(self, "backup_vault")
+
+    @property
+    @pulumi.getter(name="scheduledBackupEnabled")
+    def scheduled_backup_enabled(self) -> Optional[bool]:
+        """
+        When set to true, scheduled backup is enabled on the volume. Omit if no backup_policy is specified.
+        """
+        return pulumi.get(self, "scheduled_backup_enabled")
+
+
 @pulumi.output_type
 class VolumeExportPolicy(dict):
     def __init__(__self__, *,

pulumi_gcp/netapp/volume.py

@@ -21,6 +21,7 @@ class VolumeArgs:
                  protocols: pulumi.Input[Sequence[pulumi.Input[str]]],
                  share_name: pulumi.Input[str],
                  storage_pool: pulumi.Input[str],
+                 backup_config: Optional[pulumi.Input['VolumeBackupConfigArgs']] = None,
                  deletion_policy: Optional[pulumi.Input[str]] = None,
                  description: Optional[pulumi.Input[str]] = None,
                  export_policy: Optional[pulumi.Input['VolumeExportPolicyArgs']] = None,
@@ -43,6 +44,8 @@ class VolumeArgs:
                Each value may be one of: `NFSV3`, `NFSV4`, `SMB`.
         :param pulumi.Input[str] share_name: Share name (SMB) or export path (NFS) of the volume. Needs to be unique per location.
         :param pulumi.Input[str] storage_pool: Name of the storage pool to create the volume in. Pool needs enough spare capacity to accomodate the volume.
+        :param pulumi.Input['VolumeBackupConfigArgs'] backup_config: Backup configuration for the volume.
+               Structure is documented below.
         :param pulumi.Input[str] deletion_policy: Policy to determine if the volume should be deleted forcefully.
                Volumes may have nested snapshot resources. Deleting such a volume will fail.
                Setting this parameter to FORCE will delete volumes including nested snapshots.
@@ -80,6 +83,8 @@ class VolumeArgs:
         pulumi.set(__self__, "protocols", protocols)
         pulumi.set(__self__, "share_name", share_name)
         pulumi.set(__self__, "storage_pool", storage_pool)
+        if backup_config is not None:
+            pulumi.set(__self__, "backup_config", backup_config)
         if deletion_policy is not None:
             pulumi.set(__self__, "deletion_policy", deletion_policy)
         if description is not None:
@@ -170,6 +175,19 @@ class VolumeArgs:
     def storage_pool(self, value: pulumi.Input[str]):
         pulumi.set(self, "storage_pool", value)
 
+    @property
+    @pulumi.getter(name="backupConfig")
+    def backup_config(self) -> Optional[pulumi.Input['VolumeBackupConfigArgs']]:
+        """
+        Backup configuration for the volume.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "backup_config")
+
+    @backup_config.setter
+    def backup_config(self, value: Optional[pulumi.Input['VolumeBackupConfigArgs']]):
+        pulumi.set(self, "backup_config", value)
+
     @property
     @pulumi.getter(name="deletionPolicy")
     def deletion_policy(self) -> Optional[pulumi.Input[str]]:
@@ -360,6 +378,7 @@ class VolumeArgs:
 class _VolumeState:
     def __init__(__self__, *,
                  active_directory: Optional[pulumi.Input[str]] = None,
+                 backup_config: Optional[pulumi.Input['VolumeBackupConfigArgs']] = None,
                  capacity_gib: Optional[pulumi.Input[str]] = None,
                  create_time: Optional[pulumi.Input[str]] = None,
                  deletion_policy: Optional[pulumi.Input[str]] = None,
@@ -396,6 +415,8 @@ class _VolumeState:
         """
         Input properties used for looking up and filtering Volume resources.
         :param pulumi.Input[str] active_directory: Reports the resource name of the Active Directory policy being used. Inherited from storage pool.
+        :param pulumi.Input['VolumeBackupConfigArgs'] backup_config: Backup configuration for the volume.
+               Structure is documented below.
         :param pulumi.Input[str] capacity_gib: Capacity of the volume (in GiB).
         :param pulumi.Input[str] create_time: Create time of the volume. A timestamp in RFC3339 UTC "Zulu" format. Examples: "2023-06-22T09:13:01.617Z".
         :param pulumi.Input[str] deletion_policy: Policy to determine if the volume should be deleted forcefully.
@@ -452,6 +473,8 @@ class _VolumeState:
         """
         if active_directory is not None:
             pulumi.set(__self__, "active_directory", active_directory)
+        if backup_config is not None:
+            pulumi.set(__self__, "backup_config", backup_config)
         if capacity_gib is not None:
             pulumi.set(__self__, "capacity_gib", capacity_gib)
         if create_time is not None:
@@ -531,6 +554,19 @@ class _VolumeState:
     def active_directory(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "active_directory", value)
 
+    @property
+    @pulumi.getter(name="backupConfig")
+    def backup_config(self) -> Optional[pulumi.Input['VolumeBackupConfigArgs']]:
+        """
+        Backup configuration for the volume.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "backup_config")
+
+    @backup_config.setter
+    def backup_config(self, value: Optional[pulumi.Input['VolumeBackupConfigArgs']]):
+        pulumi.set(self, "backup_config", value)
+
     @property
     @pulumi.getter(name="capacityGib")
     def capacity_gib(self) -> Optional[pulumi.Input[str]]:
@@ -953,6 +989,7 @@ class Volume(pulumi.CustomResource):
     def __init__(__self__,
                  resource_name: str,
                  opts: Optional[pulumi.ResourceOptions] = None,
+                 backup_config: Optional[pulumi.Input[pulumi.InputType['VolumeBackupConfigArgs']]] = None,
                  capacity_gib: Optional[pulumi.Input[str]] = None,
                  deletion_policy: Optional[pulumi.Input[str]] = None,
                  description: Optional[pulumi.Input[str]] = None,
@@ -1038,6 +1075,8 @@ class Volume(pulumi.CustomResource):
 
         :param str resource_name: The name of the resource.
         :param pulumi.ResourceOptions opts: Options for the resource.
+        :param pulumi.Input[pulumi.InputType['VolumeBackupConfigArgs']] backup_config: Backup configuration for the volume.
+               Structure is documented below.
         :param pulumi.Input[str] capacity_gib: Capacity of the volume (in GiB).
         :param pulumi.Input[str] deletion_policy: Policy to determine if the volume should be deleted forcefully.
                Volumes may have nested snapshot resources. Deleting such a volume will fail.
@@ -1160,6 +1199,7 @@ class Volume(pulumi.CustomResource):
     def _internal_init(__self__,
                  resource_name: str,
                  opts: Optional[pulumi.ResourceOptions] = None,
+                 backup_config: Optional[pulumi.Input[pulumi.InputType['VolumeBackupConfigArgs']]] = None,
                  capacity_gib: Optional[pulumi.Input[str]] = None,
                  deletion_policy: Optional[pulumi.Input[str]] = None,
                  description: Optional[pulumi.Input[str]] = None,
@@ -1188,6 +1228,7 @@ class Volume(pulumi.CustomResource):
                 raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource')
             __props__ = VolumeArgs.__new__(VolumeArgs)
 
+            __props__.__dict__["backup_config"] = backup_config
             if capacity_gib is None and not opts.urn:
                 raise TypeError("Missing required property 'capacity_gib'")
             __props__.__dict__["capacity_gib"] = capacity_gib
@@ -1245,6 +1286,7 @@ class Volume(pulumi.CustomResource):
             id: pulumi.Input[str],
             opts: Optional[pulumi.ResourceOptions] = None,
             active_directory: Optional[pulumi.Input[str]] = None,
+            backup_config: Optional[pulumi.Input[pulumi.InputType['VolumeBackupConfigArgs']]] = None,
             capacity_gib: Optional[pulumi.Input[str]] = None,
             create_time: Optional[pulumi.Input[str]] = None,
             deletion_policy: Optional[pulumi.Input[str]] = None,
@@ -1286,6 +1328,8 @@ class Volume(pulumi.CustomResource):
         :param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
         :param pulumi.ResourceOptions opts: Options for the resource.
         :param pulumi.Input[str] active_directory: Reports the resource name of the Active Directory policy being used. Inherited from storage pool.
+        :param pulumi.Input[pulumi.InputType['VolumeBackupConfigArgs']] backup_config: Backup configuration for the volume.
+               Structure is documented below.
         :param pulumi.Input[str] capacity_gib: Capacity of the volume (in GiB).
         :param pulumi.Input[str] create_time: Create time of the volume. A timestamp in RFC3339 UTC "Zulu" format. Examples: "2023-06-22T09:13:01.617Z".
         :param pulumi.Input[str] deletion_policy: Policy to determine if the volume should be deleted forcefully.
@@ -1345,6 +1389,7 @@ class Volume(pulumi.CustomResource):
         __props__ = _VolumeState.__new__(_VolumeState)
 
         __props__.__dict__["active_directory"] = active_directory
+        __props__.__dict__["backup_config"] = backup_config
         __props__.__dict__["capacity_gib"] = capacity_gib
         __props__.__dict__["create_time"] = create_time
         __props__.__dict__["deletion_policy"] = deletion_policy
@@ -1388,6 +1433,15 @@ class Volume(pulumi.CustomResource):
         """
         return pulumi.get(self, "active_directory")
 
+    @property
+    @pulumi.getter(name="backupConfig")
+    def backup_config(self) -> pulumi.Output[Optional['outputs.VolumeBackupConfig']]:
+        """
+        Backup configuration for the volume.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "backup_config")
+
     @property
     @pulumi.getter(name="capacityGib")
     def capacity_gib(self) -> pulumi.Output[str]:

pulumi_gcp/networkservices/__init__.py

@@ -16,6 +16,7 @@ from .lb_route_extension import *
 from .lb_traffic_extension import *
 from .mesh import *
 from .service_binding import *
+from .service_lb_policies import *
 from .tcp_route import *
 from .tls_route import *
 from ._inputs import *

pulumi_gcp/networkservices/_inputs.py

@@ -78,6 +78,8 @@ __all__ = [
     'LbTrafficExtensionExtensionChainArgs',
     'LbTrafficExtensionExtensionChainExtensionArgs',
     'LbTrafficExtensionExtensionChainMatchConditionArgs',
+    'ServiceLbPoliciesAutoCapacityDrainArgs',
+    'ServiceLbPoliciesFailoverConfigArgs',
     'TcpRouteRuleArgs',
     'TcpRouteRuleActionArgs',
     'TcpRouteRuleActionDestinationArgs',
@@ -4726,6 +4728,51 @@ class LbTrafficExtensionExtensionChainMatchConditionArgs:
         pulumi.set(self, "cel_expression", value)
 
 
+@pulumi.input_type
+class ServiceLbPoliciesAutoCapacityDrainArgs:
+    def __init__(__self__, *,
+                 enable: Optional[pulumi.Input[bool]] = None):
+        """
+        :param pulumi.Input[bool] enable: Optional. If set to 'True', an unhealthy MIG/NEG will be set as drained. - An MIG/NEG is considered unhealthy if less than 25% of the instances/endpoints in the MIG/NEG are healthy. - This option will never result in draining more than 50% of the configured IGs/NEGs for the Backend Service.
+        """
+        if enable is not None:
+            pulumi.set(__self__, "enable", enable)
+
+    @property
+    @pulumi.getter
+    def enable(self) -> Optional[pulumi.Input[bool]]:
+        """
+        Optional. If set to 'True', an unhealthy MIG/NEG will be set as drained. - An MIG/NEG is considered unhealthy if less than 25% of the instances/endpoints in the MIG/NEG are healthy. - This option will never result in draining more than 50% of the configured IGs/NEGs for the Backend Service.
+        """
+        return pulumi.get(self, "enable")
+
+    @enable.setter
+    def enable(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "enable", value)
+
+
+@pulumi.input_type
+class ServiceLbPoliciesFailoverConfigArgs:
+    def __init__(__self__, *,
+                 failover_health_threshold: pulumi.Input[int]):
+        """
+        :param pulumi.Input[int] failover_health_threshold: Optional. The percentage threshold that a load balancer will begin to send traffic to failover backends. If the percentage of endpoints in a MIG/NEG is smaller than this value, traffic would be sent to failover backends if possible. This field should be set to a value between 1 and 99. The default value is 50 for Global external HTTP(S) load balancer (classic) and Proxyless service mesh, and 70 for others.
+        """
+        pulumi.set(__self__, "failover_health_threshold", failover_health_threshold)
+
+    @property
+    @pulumi.getter(name="failoverHealthThreshold")
+    def failover_health_threshold(self) -> pulumi.Input[int]:
+        """
+        Optional. The percentage threshold that a load balancer will begin to send traffic to failover backends. If the percentage of endpoints in a MIG/NEG is smaller than this value, traffic would be sent to failover backends if possible. This field should be set to a value between 1 and 99. The default value is 50 for Global external HTTP(S) load balancer (classic) and Proxyless service mesh, and 70 for others.
+        """
+        return pulumi.get(self, "failover_health_threshold")
+
+    @failover_health_threshold.setter
+    def failover_health_threshold(self, value: pulumi.Input[int]):
+        pulumi.set(self, "failover_health_threshold", value)
+
+
 @pulumi.input_type
 class TcpRouteRuleArgs:
     def __init__(__self__, *,

pulumi_gcp/networkservices/outputs.py

@@ -79,6 +79,8 @@ __all__ = [
     'LbTrafficExtensionExtensionChain',
     'LbTrafficExtensionExtensionChainExtension',
     'LbTrafficExtensionExtensionChainMatchCondition',
+    'ServiceLbPoliciesAutoCapacityDrain',
+    'ServiceLbPoliciesFailoverConfig',
     'TcpRouteRule',
     'TcpRouteRuleAction',
     'TcpRouteRuleActionDestination',
@@ -4975,6 +4977,60 @@ class LbTrafficExtensionExtensionChainMatchCondition(dict):
         return pulumi.get(self, "cel_expression")
 
 
+@pulumi.output_type
+class ServiceLbPoliciesAutoCapacityDrain(dict):
+    def __init__(__self__, *,
+                 enable: Optional[bool] = None):
+        """
+        :param bool enable: Optional. If set to 'True', an unhealthy MIG/NEG will be set as drained. - An MIG/NEG is considered unhealthy if less than 25% of the instances/endpoints in the MIG/NEG are healthy. - This option will never result in draining more than 50% of the configured IGs/NEGs for the Backend Service.
+        """
+        if enable is not None:
+            pulumi.set(__self__, "enable", enable)
+
+    @property
+    @pulumi.getter
+    def enable(self) -> Optional[bool]:
+        """
+        Optional. If set to 'True', an unhealthy MIG/NEG will be set as drained. - An MIG/NEG is considered unhealthy if less than 25% of the instances/endpoints in the MIG/NEG are healthy. - This option will never result in draining more than 50% of the configured IGs/NEGs for the Backend Service.
+        """
+        return pulumi.get(self, "enable")
+
+
+@pulumi.output_type
+class ServiceLbPoliciesFailoverConfig(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "failoverHealthThreshold":
+            suggest = "failover_health_threshold"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ServiceLbPoliciesFailoverConfig. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ServiceLbPoliciesFailoverConfig.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ServiceLbPoliciesFailoverConfig.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 failover_health_threshold: int):
+        """
+        :param int failover_health_threshold: Optional. The percentage threshold that a load balancer will begin to send traffic to failover backends. If the percentage of endpoints in a MIG/NEG is smaller than this value, traffic would be sent to failover backends if possible. This field should be set to a value between 1 and 99. The default value is 50 for Global external HTTP(S) load balancer (classic) and Proxyless service mesh, and 70 for others.
+        """
+        pulumi.set(__self__, "failover_health_threshold", failover_health_threshold)
+
+    @property
+    @pulumi.getter(name="failoverHealthThreshold")
+    def failover_health_threshold(self) -> int:
+        """
+        Optional. The percentage threshold that a load balancer will begin to send traffic to failover backends. If the percentage of endpoints in a MIG/NEG is smaller than this value, traffic would be sent to failover backends if possible. This field should be set to a value between 1 and 99. The default value is 50 for Global external HTTP(S) load balancer (classic) and Proxyless service mesh, and 70 for others.
+        """
+        return pulumi.get(self, "failover_health_threshold")
+
+
 @pulumi.output_type
 class TcpRouteRule(dict):
     def __init__(__self__, *,