pulumi-gcp 8.2.0a1726671837__py3-none-any.whl → 8.3.0__py3-none-any.whl

pulumi_gcp/secretmanager/_inputs.py

@@ -15,6 +15,18 @@ else:
 from .. import _utilities
 
 __all__ = [
+    'RegionalSecretCustomerManagedEncryptionArgs',
+    'RegionalSecretCustomerManagedEncryptionArgsDict',
+    'RegionalSecretIamBindingConditionArgs',
+    'RegionalSecretIamBindingConditionArgsDict',
+    'RegionalSecretIamMemberConditionArgs',
+    'RegionalSecretIamMemberConditionArgsDict',
+    'RegionalSecretRotationArgs',
+    'RegionalSecretRotationArgsDict',
+    'RegionalSecretTopicArgs',
+    'RegionalSecretTopicArgsDict',
+    'RegionalSecretVersionCustomerManagedEncryptionArgs',
+    'RegionalSecretVersionCustomerManagedEncryptionArgsDict',
     'SecretIamBindingConditionArgs',
     'SecretIamBindingConditionArgsDict',
     'SecretIamMemberConditionArgs',
@@ -39,6 +51,302 @@ __all__ = [
 
 MYPY = False
 
+if not MYPY:
+    class RegionalSecretCustomerManagedEncryptionArgsDict(TypedDict):
+        kms_key_name: pulumi.Input[str]
+        """
+        The resource name of the Cloud KMS CryptoKey used to encrypt secret payloads.
+        """
+elif False:
+    RegionalSecretCustomerManagedEncryptionArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class RegionalSecretCustomerManagedEncryptionArgs:
+    def __init__(__self__, *,
+                 kms_key_name: pulumi.Input[str]):
+        """
+        :param pulumi.Input[str] kms_key_name: The resource name of the Cloud KMS CryptoKey used to encrypt secret payloads.
+        """
+        pulumi.set(__self__, "kms_key_name", kms_key_name)
+
+    @property
+    @pulumi.getter(name="kmsKeyName")
+    def kms_key_name(self) -> pulumi.Input[str]:
+        """
+        The resource name of the Cloud KMS CryptoKey used to encrypt secret payloads.
+        """
+        return pulumi.get(self, "kms_key_name")
+
+    @kms_key_name.setter
+    def kms_key_name(self, value: pulumi.Input[str]):
+        pulumi.set(self, "kms_key_name", value)
+
+
+if not MYPY:
+    class RegionalSecretIamBindingConditionArgsDict(TypedDict):
+        expression: pulumi.Input[str]
+        """
+        Textual representation of an expression in Common Expression Language syntax.
+        """
+        title: pulumi.Input[str]
+        """
+        A title for the expression, i.e. a short string describing its purpose.
+        """
+        description: NotRequired[pulumi.Input[str]]
+elif False:
+    RegionalSecretIamBindingConditionArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class RegionalSecretIamBindingConditionArgs:
+    def __init__(__self__, *,
+                 expression: pulumi.Input[str],
+                 title: pulumi.Input[str],
+                 description: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[str] expression: Textual representation of an expression in Common Expression Language syntax.
+        :param pulumi.Input[str] title: A title for the expression, i.e. a short string describing its purpose.
+        """
+        pulumi.set(__self__, "expression", expression)
+        pulumi.set(__self__, "title", title)
+        if description is not None:
+            pulumi.set(__self__, "description", description)
+
+    @property
+    @pulumi.getter
+    def expression(self) -> pulumi.Input[str]:
+        """
+        Textual representation of an expression in Common Expression Language syntax.
+        """
+        return pulumi.get(self, "expression")
+
+    @expression.setter
+    def expression(self, value: pulumi.Input[str]):
+        pulumi.set(self, "expression", value)
+
+    @property
+    @pulumi.getter
+    def title(self) -> pulumi.Input[str]:
+        """
+        A title for the expression, i.e. a short string describing its purpose.
+        """
+        return pulumi.get(self, "title")
+
+    @title.setter
+    def title(self, value: pulumi.Input[str]):
+        pulumi.set(self, "title", value)
+
+    @property
+    @pulumi.getter
+    def description(self) -> Optional[pulumi.Input[str]]:
+        return pulumi.get(self, "description")
+
+    @description.setter
+    def description(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "description", value)
+
+
+if not MYPY:
+    class RegionalSecretIamMemberConditionArgsDict(TypedDict):
+        expression: pulumi.Input[str]
+        """
+        Textual representation of an expression in Common Expression Language syntax.
+        """
+        title: pulumi.Input[str]
+        """
+        A title for the expression, i.e. a short string describing its purpose.
+        """
+        description: NotRequired[pulumi.Input[str]]
+elif False:
+    RegionalSecretIamMemberConditionArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class RegionalSecretIamMemberConditionArgs:
+    def __init__(__self__, *,
+                 expression: pulumi.Input[str],
+                 title: pulumi.Input[str],
+                 description: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[str] expression: Textual representation of an expression in Common Expression Language syntax.
+        :param pulumi.Input[str] title: A title for the expression, i.e. a short string describing its purpose.
+        """
+        pulumi.set(__self__, "expression", expression)
+        pulumi.set(__self__, "title", title)
+        if description is not None:
+            pulumi.set(__self__, "description", description)
+
+    @property
+    @pulumi.getter
+    def expression(self) -> pulumi.Input[str]:
+        """
+        Textual representation of an expression in Common Expression Language syntax.
+        """
+        return pulumi.get(self, "expression")
+
+    @expression.setter
+    def expression(self, value: pulumi.Input[str]):
+        pulumi.set(self, "expression", value)
+
+    @property
+    @pulumi.getter
+    def title(self) -> pulumi.Input[str]:
+        """
+        A title for the expression, i.e. a short string describing its purpose.
+        """
+        return pulumi.get(self, "title")
+
+    @title.setter
+    def title(self, value: pulumi.Input[str]):
+        pulumi.set(self, "title", value)
+
+    @property
+    @pulumi.getter
+    def description(self) -> Optional[pulumi.Input[str]]:
+        return pulumi.get(self, "description")
+
+    @description.setter
+    def description(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "description", value)
+
+
+if not MYPY:
+    class RegionalSecretRotationArgsDict(TypedDict):
+        next_rotation_time: NotRequired[pulumi.Input[str]]
+        """
+        Timestamp in UTC at which the Secret is scheduled to rotate.
+        A timestamp in RFC3339 UTC "Zulu" format, with nanosecond resolution and up to nine
+        fractional digits. Examples: "2014-10-02T15:01:23Z" and "2014-10-02T15:01:23.045123456Z".
+        """
+        rotation_period: NotRequired[pulumi.Input[str]]
+        """
+        The Duration between rotation notifications. Must be in seconds and at least 3600s (1h)
+        and at most 3153600000s (100 years). If rotationPeriod is set, `next_rotation_time` must
+        be set. `next_rotation_time` will be advanced by this period when the service
+        automatically sends rotation notifications.
+        """
+elif False:
+    RegionalSecretRotationArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class RegionalSecretRotationArgs:
+    def __init__(__self__, *,
+                 next_rotation_time: Optional[pulumi.Input[str]] = None,
+                 rotation_period: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[str] next_rotation_time: Timestamp in UTC at which the Secret is scheduled to rotate.
+               A timestamp in RFC3339 UTC "Zulu" format, with nanosecond resolution and up to nine
+               fractional digits. Examples: "2014-10-02T15:01:23Z" and "2014-10-02T15:01:23.045123456Z".
+        :param pulumi.Input[str] rotation_period: The Duration between rotation notifications. Must be in seconds and at least 3600s (1h)
+               and at most 3153600000s (100 years). If rotationPeriod is set, `next_rotation_time` must
+               be set. `next_rotation_time` will be advanced by this period when the service
+               automatically sends rotation notifications.
+        """
+        if next_rotation_time is not None:
+            pulumi.set(__self__, "next_rotation_time", next_rotation_time)
+        if rotation_period is not None:
+            pulumi.set(__self__, "rotation_period", rotation_period)
+
+    @property
+    @pulumi.getter(name="nextRotationTime")
+    def next_rotation_time(self) -> Optional[pulumi.Input[str]]:
+        """
+        Timestamp in UTC at which the Secret is scheduled to rotate.
+        A timestamp in RFC3339 UTC "Zulu" format, with nanosecond resolution and up to nine
+        fractional digits. Examples: "2014-10-02T15:01:23Z" and "2014-10-02T15:01:23.045123456Z".
+        """
+        return pulumi.get(self, "next_rotation_time")
+
+    @next_rotation_time.setter
+    def next_rotation_time(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "next_rotation_time", value)
+
+    @property
+    @pulumi.getter(name="rotationPeriod")
+    def rotation_period(self) -> Optional[pulumi.Input[str]]:
+        """
+        The Duration between rotation notifications. Must be in seconds and at least 3600s (1h)
+        and at most 3153600000s (100 years). If rotationPeriod is set, `next_rotation_time` must
+        be set. `next_rotation_time` will be advanced by this period when the service
+        automatically sends rotation notifications.
+        """
+        return pulumi.get(self, "rotation_period")
+
+    @rotation_period.setter
+    def rotation_period(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "rotation_period", value)
+
+
+if not MYPY:
+    class RegionalSecretTopicArgsDict(TypedDict):
+        name: pulumi.Input[str]
+        """
+        The resource name of the Pub/Sub topic that will be published to, in the following format:
+        projects/*/topics/*. For publication to succeed, the Secret Manager Service
+        Agent service account must have pubsub.publisher permissions on the topic.
+        """
+elif False:
+    RegionalSecretTopicArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class RegionalSecretTopicArgs:
+    def __init__(__self__, *,
+                 name: pulumi.Input[str]):
+        """
+        :param pulumi.Input[str] name: The resource name of the Pub/Sub topic that will be published to, in the following format:
+               projects/*/topics/*. For publication to succeed, the Secret Manager Service
+               Agent service account must have pubsub.publisher permissions on the topic.
+        """
+        pulumi.set(__self__, "name", name)
+
+    @property
+    @pulumi.getter
+    def name(self) -> pulumi.Input[str]:
+        """
+        The resource name of the Pub/Sub topic that will be published to, in the following format:
+        projects/*/topics/*. For publication to succeed, the Secret Manager Service
+        Agent service account must have pubsub.publisher permissions on the topic.
+        """
+        return pulumi.get(self, "name")
+
+    @name.setter
+    def name(self, value: pulumi.Input[str]):
+        pulumi.set(self, "name", value)
+
+
+if not MYPY:
+    class RegionalSecretVersionCustomerManagedEncryptionArgsDict(TypedDict):
+        kms_key_version_name: NotRequired[pulumi.Input[str]]
+        """
+        (Output)
+        The resource name of the Cloud KMS CryptoKey used to encrypt secret payloads.
+        """
+elif False:
+    RegionalSecretVersionCustomerManagedEncryptionArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class RegionalSecretVersionCustomerManagedEncryptionArgs:
+    def __init__(__self__, *,
+                 kms_key_version_name: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[str] kms_key_version_name: (Output)
+               The resource name of the Cloud KMS CryptoKey used to encrypt secret payloads.
+        """
+        if kms_key_version_name is not None:
+            pulumi.set(__self__, "kms_key_version_name", kms_key_version_name)
+
+    @property
+    @pulumi.getter(name="kmsKeyVersionName")
+    def kms_key_version_name(self) -> Optional[pulumi.Input[str]]:
+        """
+        (Output)
+        The resource name of the Cloud KMS CryptoKey used to encrypt secret payloads.
+        """
+        return pulumi.get(self, "kms_key_version_name")
+
+    @kms_key_version_name.setter
+    def kms_key_version_name(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "kms_key_version_name", value)
+
+
 if not MYPY:
     class SecretIamBindingConditionArgsDict(TypedDict):
         expression: pulumi.Input[str]

pulumi_gcp/secretmanager/get_regional_secret.py

@@ -0,0 +1,279 @@
+# coding=utf-8
+# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
+# *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+import copy
+import warnings
+import sys
+import pulumi
+import pulumi.runtime
+from typing import Any, Mapping, Optional, Sequence, Union, overload
+if sys.version_info >= (3, 11):
+    from typing import NotRequired, TypedDict, TypeAlias
+else:
+    from typing_extensions import NotRequired, TypedDict, TypeAlias
+from .. import _utilities
+from . import outputs
+
+__all__ = [
+    'GetRegionalSecretResult',
+    'AwaitableGetRegionalSecretResult',
+    'get_regional_secret',
+    'get_regional_secret_output',
+]
+
+@pulumi.output_type
+class GetRegionalSecretResult:
+    """
+    A collection of values returned by getRegionalSecret.
+    """
+    def __init__(__self__, annotations=None, create_time=None, customer_managed_encryptions=None, effective_annotations=None, effective_labels=None, expire_time=None, id=None, labels=None, location=None, name=None, project=None, pulumi_labels=None, rotations=None, secret_id=None, topics=None, ttl=None, version_aliases=None, version_destroy_ttl=None):
+        if annotations and not isinstance(annotations, dict):
+            raise TypeError("Expected argument 'annotations' to be a dict")
+        pulumi.set(__self__, "annotations", annotations)
+        if create_time and not isinstance(create_time, str):
+            raise TypeError("Expected argument 'create_time' to be a str")
+        pulumi.set(__self__, "create_time", create_time)
+        if customer_managed_encryptions and not isinstance(customer_managed_encryptions, list):
+            raise TypeError("Expected argument 'customer_managed_encryptions' to be a list")
+        pulumi.set(__self__, "customer_managed_encryptions", customer_managed_encryptions)
+        if effective_annotations and not isinstance(effective_annotations, dict):
+            raise TypeError("Expected argument 'effective_annotations' to be a dict")
+        pulumi.set(__self__, "effective_annotations", effective_annotations)
+        if effective_labels and not isinstance(effective_labels, dict):
+            raise TypeError("Expected argument 'effective_labels' to be a dict")
+        pulumi.set(__self__, "effective_labels", effective_labels)
+        if expire_time and not isinstance(expire_time, str):
+            raise TypeError("Expected argument 'expire_time' to be a str")
+        pulumi.set(__self__, "expire_time", expire_time)
+        if id and not isinstance(id, str):
+            raise TypeError("Expected argument 'id' to be a str")
+        pulumi.set(__self__, "id", id)
+        if labels and not isinstance(labels, dict):
+            raise TypeError("Expected argument 'labels' to be a dict")
+        pulumi.set(__self__, "labels", labels)
+        if location and not isinstance(location, str):
+            raise TypeError("Expected argument 'location' to be a str")
+        pulumi.set(__self__, "location", location)
+        if name and not isinstance(name, str):
+            raise TypeError("Expected argument 'name' to be a str")
+        pulumi.set(__self__, "name", name)
+        if project and not isinstance(project, str):
+            raise TypeError("Expected argument 'project' to be a str")
+        pulumi.set(__self__, "project", project)
+        if pulumi_labels and not isinstance(pulumi_labels, dict):
+            raise TypeError("Expected argument 'pulumi_labels' to be a dict")
+        pulumi.set(__self__, "pulumi_labels", pulumi_labels)
+        if rotations and not isinstance(rotations, list):
+            raise TypeError("Expected argument 'rotations' to be a list")
+        pulumi.set(__self__, "rotations", rotations)
+        if secret_id and not isinstance(secret_id, str):
+            raise TypeError("Expected argument 'secret_id' to be a str")
+        pulumi.set(__self__, "secret_id", secret_id)
+        if topics and not isinstance(topics, list):
+            raise TypeError("Expected argument 'topics' to be a list")
+        pulumi.set(__self__, "topics", topics)
+        if ttl and not isinstance(ttl, str):
+            raise TypeError("Expected argument 'ttl' to be a str")
+        pulumi.set(__self__, "ttl", ttl)
+        if version_aliases and not isinstance(version_aliases, dict):
+            raise TypeError("Expected argument 'version_aliases' to be a dict")
+        pulumi.set(__self__, "version_aliases", version_aliases)
+        if version_destroy_ttl and not isinstance(version_destroy_ttl, str):
+            raise TypeError("Expected argument 'version_destroy_ttl' to be a str")
+        pulumi.set(__self__, "version_destroy_ttl", version_destroy_ttl)
+
+    @property
+    @pulumi.getter
+    def annotations(self) -> Mapping[str, str]:
+        return pulumi.get(self, "annotations")
+
+    @property
+    @pulumi.getter(name="createTime")
+    def create_time(self) -> str:
+        return pulumi.get(self, "create_time")
+
+    @property
+    @pulumi.getter(name="customerManagedEncryptions")
+    def customer_managed_encryptions(self) -> Sequence['outputs.GetRegionalSecretCustomerManagedEncryptionResult']:
+        return pulumi.get(self, "customer_managed_encryptions")
+
+    @property
+    @pulumi.getter(name="effectiveAnnotations")
+    def effective_annotations(self) -> Mapping[str, str]:
+        return pulumi.get(self, "effective_annotations")
+
+    @property
+    @pulumi.getter(name="effectiveLabels")
+    def effective_labels(self) -> Mapping[str, str]:
+        return pulumi.get(self, "effective_labels")
+
+    @property
+    @pulumi.getter(name="expireTime")
+    def expire_time(self) -> str:
+        return pulumi.get(self, "expire_time")
+
+    @property
+    @pulumi.getter
+    def id(self) -> str:
+        """
+        The provider-assigned unique ID for this managed resource.
+        """
+        return pulumi.get(self, "id")
+
+    @property
+    @pulumi.getter
+    def labels(self) -> Mapping[str, str]:
+        return pulumi.get(self, "labels")
+
+    @property
+    @pulumi.getter
+    def location(self) -> str:
+        return pulumi.get(self, "location")
+
+    @property
+    @pulumi.getter
+    def name(self) -> str:
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter
+    def project(self) -> Optional[str]:
+        return pulumi.get(self, "project")
+
+    @property
+    @pulumi.getter(name="pulumiLabels")
+    def pulumi_labels(self) -> Mapping[str, str]:
+        return pulumi.get(self, "pulumi_labels")
+
+    @property
+    @pulumi.getter
+    def rotations(self) -> Sequence['outputs.GetRegionalSecretRotationResult']:
+        return pulumi.get(self, "rotations")
+
+    @property
+    @pulumi.getter(name="secretId")
+    def secret_id(self) -> str:
+        return pulumi.get(self, "secret_id")
+
+    @property
+    @pulumi.getter
+    def topics(self) -> Sequence['outputs.GetRegionalSecretTopicResult']:
+        return pulumi.get(self, "topics")
+
+    @property
+    @pulumi.getter
+    def ttl(self) -> str:
+        return pulumi.get(self, "ttl")
+
+    @property
+    @pulumi.getter(name="versionAliases")
+    def version_aliases(self) -> Mapping[str, str]:
+        return pulumi.get(self, "version_aliases")
+
+    @property
+    @pulumi.getter(name="versionDestroyTtl")
+    def version_destroy_ttl(self) -> str:
+        return pulumi.get(self, "version_destroy_ttl")
+
+
+class AwaitableGetRegionalSecretResult(GetRegionalSecretResult):
+    # pylint: disable=using-constant-test
+    def __await__(self):
+        if False:
+            yield self
+        return GetRegionalSecretResult(
+            annotations=self.annotations,
+            create_time=self.create_time,
+            customer_managed_encryptions=self.customer_managed_encryptions,
+            effective_annotations=self.effective_annotations,
+            effective_labels=self.effective_labels,
+            expire_time=self.expire_time,
+            id=self.id,
+            labels=self.labels,
+            location=self.location,
+            name=self.name,
+            project=self.project,
+            pulumi_labels=self.pulumi_labels,
+            rotations=self.rotations,
+            secret_id=self.secret_id,
+            topics=self.topics,
+            ttl=self.ttl,
+            version_aliases=self.version_aliases,
+            version_destroy_ttl=self.version_destroy_ttl)
+
+
+def get_regional_secret(location: Optional[str] = None,
+                        project: Optional[str] = None,
+                        secret_id: Optional[str] = None,
+                        opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetRegionalSecretResult:
+    """
+    Use this data source to get information about a Secret Manager Regional Secret
+
+    ## Example Usage
+
+    ```python
+    import pulumi
+    import pulumi_gcp as gcp
+
+    secret_datasource = gcp.secretmanager.get_regional_secret(secret_id="secretname",
+        location="us-central1")
+    ```
+
+
+    :param str location: The location of the regional secret. eg us-central1
+    :param str project: The ID of the project in which the resource belongs.
+    :param str secret_id: The name of the regional secret.
+    """
+    __args__ = dict()
+    __args__['location'] = location
+    __args__['project'] = project
+    __args__['secretId'] = secret_id
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke('gcp:secretmanager/getRegionalSecret:getRegionalSecret', __args__, opts=opts, typ=GetRegionalSecretResult).value
+
+    return AwaitableGetRegionalSecretResult(
+        annotations=pulumi.get(__ret__, 'annotations'),
+        create_time=pulumi.get(__ret__, 'create_time'),
+        customer_managed_encryptions=pulumi.get(__ret__, 'customer_managed_encryptions'),
+        effective_annotations=pulumi.get(__ret__, 'effective_annotations'),
+        effective_labels=pulumi.get(__ret__, 'effective_labels'),
+        expire_time=pulumi.get(__ret__, 'expire_time'),
+        id=pulumi.get(__ret__, 'id'),
+        labels=pulumi.get(__ret__, 'labels'),
+        location=pulumi.get(__ret__, 'location'),
+        name=pulumi.get(__ret__, 'name'),
+        project=pulumi.get(__ret__, 'project'),
+        pulumi_labels=pulumi.get(__ret__, 'pulumi_labels'),
+        rotations=pulumi.get(__ret__, 'rotations'),
+        secret_id=pulumi.get(__ret__, 'secret_id'),
+        topics=pulumi.get(__ret__, 'topics'),
+        ttl=pulumi.get(__ret__, 'ttl'),
+        version_aliases=pulumi.get(__ret__, 'version_aliases'),
+        version_destroy_ttl=pulumi.get(__ret__, 'version_destroy_ttl'))
+
+
+@_utilities.lift_output_func(get_regional_secret)
+def get_regional_secret_output(location: Optional[pulumi.Input[str]] = None,
+                               project: Optional[pulumi.Input[Optional[str]]] = None,
+                               secret_id: Optional[pulumi.Input[str]] = None,
+                               opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetRegionalSecretResult]:
+    """
+    Use this data source to get information about a Secret Manager Regional Secret
+
+    ## Example Usage
+
+    ```python
+    import pulumi
+    import pulumi_gcp as gcp
+
+    secret_datasource = gcp.secretmanager.get_regional_secret(secret_id="secretname",
+        location="us-central1")
+    ```
+
+
+    :param str location: The location of the regional secret. eg us-central1
+    :param str project: The ID of the project in which the resource belongs.
+    :param str secret_id: The name of the regional secret.
+    """
+    ...