pulumi-gcp 8.35.0a1750142992__py3-none-any.whl → 8.35.0a1750229953__py3-none-any.whl

pulumi_gcp/compute/vpn_tunnel.py

@@ -14,6 +14,8 @@ if sys.version_info >= (3, 11):
 else:
     from typing_extensions import NotRequired, TypedDict, TypeAlias
 from .. import _utilities
+from . import outputs
+from ._inputs import *
 
 __all__ = ['VPNTunnelArgs', 'VPNTunnel']
 
@@ -21,6 +23,7 @@ __all__ = ['VPNTunnelArgs', 'VPNTunnel']
 class VPNTunnelArgs:
     def __init__(__self__, *,
                  shared_secret: pulumi.Input[builtins.str],
+                 cipher_suite: Optional[pulumi.Input['VPNTunnelCipherSuiteArgs']] = None,
                  description: Optional[pulumi.Input[builtins.str]] = None,
                  ike_version: Optional[pulumi.Input[builtins.int]] = None,
                  labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None,
@@ -45,6 +48,8 @@ class VPNTunnelArgs:
                
                
                - - -
+        :param pulumi.Input['VPNTunnelCipherSuiteArgs'] cipher_suite: User specified list of ciphers to use for the phase 1 and phase 2 of the IKE protocol.
+               Structure is documented below.
         :param pulumi.Input[builtins.str] description: An optional description of this resource.
         :param pulumi.Input[builtins.int] ike_version: IKE protocol version to use when establishing the VPN tunnel with
                peer VPN gateway.
@@ -86,6 +91,8 @@ class VPNTunnelArgs:
         :param pulumi.Input[builtins.int] vpn_gateway_interface: The interface ID of the VPN gateway with which this VPN tunnel is associated.
         """
         pulumi.set(__self__, "shared_secret", shared_secret)
+        if cipher_suite is not None:
+            pulumi.set(__self__, "cipher_suite", cipher_suite)
         if description is not None:
             pulumi.set(__self__, "description", description)
         if ike_version is not None:
@@ -136,6 +143,19 @@ class VPNTunnelArgs:
     def shared_secret(self, value: pulumi.Input[builtins.str]):
         pulumi.set(self, "shared_secret", value)
 
+    @property
+    @pulumi.getter(name="cipherSuite")
+    def cipher_suite(self) -> Optional[pulumi.Input['VPNTunnelCipherSuiteArgs']]:
+        """
+        User specified list of ciphers to use for the phase 1 and phase 2 of the IKE protocol.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "cipher_suite")
+
+    @cipher_suite.setter
+    def cipher_suite(self, value: Optional[pulumi.Input['VPNTunnelCipherSuiteArgs']]):
+        pulumi.set(self, "cipher_suite", value)
+
     @property
     @pulumi.getter
     def description(self) -> Optional[pulumi.Input[builtins.str]]:
@@ -355,6 +375,7 @@ class VPNTunnelArgs:
 @pulumi.input_type
 class _VPNTunnelState:
     def __init__(__self__, *,
+                 cipher_suite: Optional[pulumi.Input['VPNTunnelCipherSuiteArgs']] = None,
                  creation_timestamp: Optional[pulumi.Input[builtins.str]] = None,
                  description: Optional[pulumi.Input[builtins.str]] = None,
                  detailed_status: Optional[pulumi.Input[builtins.str]] = None,
@@ -382,6 +403,8 @@ class _VPNTunnelState:
                  vpn_gateway_interface: Optional[pulumi.Input[builtins.int]] = None):
         """
         Input properties used for looking up and filtering VPNTunnel resources.
+        :param pulumi.Input['VPNTunnelCipherSuiteArgs'] cipher_suite: User specified list of ciphers to use for the phase 1 and phase 2 of the IKE protocol.
+               Structure is documented below.
         :param pulumi.Input[builtins.str] creation_timestamp: Creation timestamp in RFC3339 text format.
         :param pulumi.Input[builtins.str] description: An optional description of this resource.
         :param pulumi.Input[builtins.str] detailed_status: Detailed status message for the VPN tunnel.
@@ -438,6 +461,8 @@ class _VPNTunnelState:
                This field must reference a `compute.HaVpnGateway` resource.
         :param pulumi.Input[builtins.int] vpn_gateway_interface: The interface ID of the VPN gateway with which this VPN tunnel is associated.
         """
+        if cipher_suite is not None:
+            pulumi.set(__self__, "cipher_suite", cipher_suite)
         if creation_timestamp is not None:
             pulumi.set(__self__, "creation_timestamp", creation_timestamp)
         if description is not None:
@@ -489,6 +514,19 @@ class _VPNTunnelState:
         if vpn_gateway_interface is not None:
             pulumi.set(__self__, "vpn_gateway_interface", vpn_gateway_interface)
 
+    @property
+    @pulumi.getter(name="cipherSuite")
+    def cipher_suite(self) -> Optional[pulumi.Input['VPNTunnelCipherSuiteArgs']]:
+        """
+        User specified list of ciphers to use for the phase 1 and phase 2 of the IKE protocol.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "cipher_suite")
+
+    @cipher_suite.setter
+    def cipher_suite(self, value: Optional[pulumi.Input['VPNTunnelCipherSuiteArgs']]):
+        pulumi.set(self, "cipher_suite", value)
+
     @property
     @pulumi.getter(name="creationTimestamp")
     def creation_timestamp(self) -> Optional[pulumi.Input[builtins.str]]:
@@ -826,6 +864,7 @@ class VPNTunnel(pulumi.CustomResource):
     def __init__(__self__,
                  resource_name: str,
                  opts: Optional[pulumi.ResourceOptions] = None,
+                 cipher_suite: Optional[pulumi.Input[Union['VPNTunnelCipherSuiteArgs', 'VPNTunnelCipherSuiteArgsDict']]] = None,
                  description: Optional[pulumi.Input[builtins.str]] = None,
                  ike_version: Optional[pulumi.Input[builtins.int]] = None,
                  labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None,
@@ -904,6 +943,67 @@ class VPNTunnel(pulumi.CustomResource):
             priority=1000,
             next_hop_vpn_tunnel=tunnel1.id)
         ```
+        ### Vpn Tunnel Cipher Suite
+
+        ```python
+        import pulumi
+        import pulumi_gcp as gcp
+
+        network1 = gcp.compute.Network("network1", name="network-1")
+        target_gateway = gcp.compute.VPNGateway("target_gateway",
+            name="vpn-1",
+            network=network1.id)
+        vpn_static_ip = gcp.compute.Address("vpn_static_ip", name="vpn-static-ip")
+        fr_esp = gcp.compute.ForwardingRule("fr_esp",
+            name="fr-esp",
+            ip_protocol="ESP",
+            ip_address=vpn_static_ip.address,
+            target=target_gateway.id)
+        fr_udp500 = gcp.compute.ForwardingRule("fr_udp500",
+            name="fr-udp500",
+            ip_protocol="UDP",
+            port_range="500",
+            ip_address=vpn_static_ip.address,
+            target=target_gateway.id)
+        fr_udp4500 = gcp.compute.ForwardingRule("fr_udp4500",
+            name="fr-udp4500",
+            ip_protocol="UDP",
+            port_range="4500",
+            ip_address=vpn_static_ip.address,
+            target=target_gateway.id)
+        tunnel1 = gcp.compute.VPNTunnel("tunnel1",
+            name="tunnel-cipher",
+            peer_ip="15.0.0.120",
+            shared_secret="a secret message",
+            target_vpn_gateway=target_gateway.id,
+            cipher_suite={
+                "phase1": {
+                    "encryptions": ["AES-CBC-256"],
+                    "integrities": ["HMAC-SHA2-256-128"],
+                    "prves": ["PRF-HMAC-SHA2-256"],
+                    "dhs": ["Group-14"],
+                },
+                "phase2": {
+                    "encryptions": ["AES-CBC-128"],
+                    "integrities": ["HMAC-SHA2-256-128"],
+                    "pfs": ["Group-14"],
+                },
+            },
+            labels={
+                "foo": "bar",
+            },
+            opts = pulumi.ResourceOptions(depends_on=[
+                    fr_esp,
+                    fr_udp500,
+                    fr_udp4500,
+                ]))
+        route1 = gcp.compute.Route("route1",
+            name="route1",
+            network=network1.name,
+            dest_range="15.0.0.0/24",
+            priority=1000,
+            next_hop_vpn_tunnel=tunnel1.id)
+        ```
 
         ## Import
 
@@ -937,6 +1037,8 @@ class VPNTunnel(pulumi.CustomResource):
 
         :param str resource_name: The name of the resource.
         :param pulumi.ResourceOptions opts: Options for the resource.
+        :param pulumi.Input[Union['VPNTunnelCipherSuiteArgs', 'VPNTunnelCipherSuiteArgsDict']] cipher_suite: User specified list of ciphers to use for the phase 1 and phase 2 of the IKE protocol.
+               Structure is documented below.
         :param pulumi.Input[builtins.str] description: An optional description of this resource.
         :param pulumi.Input[builtins.int] ike_version: IKE protocol version to use when establishing the VPN tunnel with
                peer VPN gateway.
@@ -1049,6 +1151,67 @@ class VPNTunnel(pulumi.CustomResource):
             priority=1000,
             next_hop_vpn_tunnel=tunnel1.id)
         ```
+        ### Vpn Tunnel Cipher Suite
+
+        ```python
+        import pulumi
+        import pulumi_gcp as gcp
+
+        network1 = gcp.compute.Network("network1", name="network-1")
+        target_gateway = gcp.compute.VPNGateway("target_gateway",
+            name="vpn-1",
+            network=network1.id)
+        vpn_static_ip = gcp.compute.Address("vpn_static_ip", name="vpn-static-ip")
+        fr_esp = gcp.compute.ForwardingRule("fr_esp",
+            name="fr-esp",
+            ip_protocol="ESP",
+            ip_address=vpn_static_ip.address,
+            target=target_gateway.id)
+        fr_udp500 = gcp.compute.ForwardingRule("fr_udp500",
+            name="fr-udp500",
+            ip_protocol="UDP",
+            port_range="500",
+            ip_address=vpn_static_ip.address,
+            target=target_gateway.id)
+        fr_udp4500 = gcp.compute.ForwardingRule("fr_udp4500",
+            name="fr-udp4500",
+            ip_protocol="UDP",
+            port_range="4500",
+            ip_address=vpn_static_ip.address,
+            target=target_gateway.id)
+        tunnel1 = gcp.compute.VPNTunnel("tunnel1",
+            name="tunnel-cipher",
+            peer_ip="15.0.0.120",
+            shared_secret="a secret message",
+            target_vpn_gateway=target_gateway.id,
+            cipher_suite={
+                "phase1": {
+                    "encryptions": ["AES-CBC-256"],
+                    "integrities": ["HMAC-SHA2-256-128"],
+                    "prves": ["PRF-HMAC-SHA2-256"],
+                    "dhs": ["Group-14"],
+                },
+                "phase2": {
+                    "encryptions": ["AES-CBC-128"],
+                    "integrities": ["HMAC-SHA2-256-128"],
+                    "pfs": ["Group-14"],
+                },
+            },
+            labels={
+                "foo": "bar",
+            },
+            opts = pulumi.ResourceOptions(depends_on=[
+                    fr_esp,
+                    fr_udp500,
+                    fr_udp4500,
+                ]))
+        route1 = gcp.compute.Route("route1",
+            name="route1",
+            network=network1.name,
+            dest_range="15.0.0.0/24",
+            priority=1000,
+            next_hop_vpn_tunnel=tunnel1.id)
+        ```
 
         ## Import
 
@@ -1095,6 +1258,7 @@ class VPNTunnel(pulumi.CustomResource):
     def _internal_init(__self__,
                  resource_name: str,
                  opts: Optional[pulumi.ResourceOptions] = None,
+                 cipher_suite: Optional[pulumi.Input[Union['VPNTunnelCipherSuiteArgs', 'VPNTunnelCipherSuiteArgsDict']]] = None,
                  description: Optional[pulumi.Input[builtins.str]] = None,
                  ike_version: Optional[pulumi.Input[builtins.int]] = None,
                  labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None,
@@ -1121,6 +1285,7 @@ class VPNTunnel(pulumi.CustomResource):
                 raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource')
             __props__ = VPNTunnelArgs.__new__(VPNTunnelArgs)
 
+            __props__.__dict__["cipher_suite"] = cipher_suite
             __props__.__dict__["description"] = description
             __props__.__dict__["ike_version"] = ike_version
             __props__.__dict__["labels"] = labels
@@ -1160,6 +1325,7 @@ class VPNTunnel(pulumi.CustomResource):
     def get(resource_name: str,
             id: pulumi.Input[str],
             opts: Optional[pulumi.ResourceOptions] = None,
+            cipher_suite: Optional[pulumi.Input[Union['VPNTunnelCipherSuiteArgs', 'VPNTunnelCipherSuiteArgsDict']]] = None,
             creation_timestamp: Optional[pulumi.Input[builtins.str]] = None,
             description: Optional[pulumi.Input[builtins.str]] = None,
             detailed_status: Optional[pulumi.Input[builtins.str]] = None,
@@ -1192,6 +1358,8 @@ class VPNTunnel(pulumi.CustomResource):
         :param str resource_name: The unique name of the resulting resource.
         :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[Union['VPNTunnelCipherSuiteArgs', 'VPNTunnelCipherSuiteArgsDict']] cipher_suite: User specified list of ciphers to use for the phase 1 and phase 2 of the IKE protocol.
+               Structure is documented below.
         :param pulumi.Input[builtins.str] creation_timestamp: Creation timestamp in RFC3339 text format.
         :param pulumi.Input[builtins.str] description: An optional description of this resource.
         :param pulumi.Input[builtins.str] detailed_status: Detailed status message for the VPN tunnel.
@@ -1252,6 +1420,7 @@ class VPNTunnel(pulumi.CustomResource):
 
         __props__ = _VPNTunnelState.__new__(_VPNTunnelState)
 
+        __props__.__dict__["cipher_suite"] = cipher_suite
         __props__.__dict__["creation_timestamp"] = creation_timestamp
         __props__.__dict__["description"] = description
         __props__.__dict__["detailed_status"] = detailed_status
@@ -1279,6 +1448,15 @@ class VPNTunnel(pulumi.CustomResource):
         __props__.__dict__["vpn_gateway_interface"] = vpn_gateway_interface
         return VPNTunnel(resource_name, opts=opts, __props__=__props__)
 
+    @property
+    @pulumi.getter(name="cipherSuite")
+    def cipher_suite(self) -> pulumi.Output[Optional['outputs.VPNTunnelCipherSuite']]:
+        """
+        User specified list of ciphers to use for the phase 1 and phase 2 of the IKE protocol.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "cipher_suite")
+
     @property
     @pulumi.getter(name="creationTimestamp")
     def creation_timestamp(self) -> pulumi.Output[builtins.str]:

pulumi_gcp/dataplex/__init__.py

@@ -29,6 +29,7 @@ from .entry_type_iam_member import *
 from .entry_type_iam_policy import *
 from .get_aspect_type_iam_policy import *
 from .get_asset_iam_policy import *
+from .get_data_quality_rules import *
 from .get_datascan_iam_policy import *
 from .get_entry_group_iam_policy import *
 from .get_entry_type_iam_policy import *

pulumi_gcp/dataplex/get_data_quality_rules.py

@@ -0,0 +1,169 @@
+# coding=utf-8
+# *** WARNING: this file was generated by pulumi-language-python. ***
+# *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+import builtins
+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__ = [
+    'GetDataQualityRulesResult',
+    'AwaitableGetDataQualityRulesResult',
+    'get_data_quality_rules',
+    'get_data_quality_rules_output',
+]
+
+@pulumi.output_type
+class GetDataQualityRulesResult:
+    """
+    A collection of values returned by getDataQualityRules.
+    """
+    def __init__(__self__, data_scan_id=None, id=None, location=None, project=None, rules=None):
+        if data_scan_id and not isinstance(data_scan_id, str):
+            raise TypeError("Expected argument 'data_scan_id' to be a str")
+        pulumi.set(__self__, "data_scan_id", data_scan_id)
+        if id and not isinstance(id, str):
+            raise TypeError("Expected argument 'id' to be a str")
+        pulumi.set(__self__, "id", id)
+        if location and not isinstance(location, str):
+            raise TypeError("Expected argument 'location' to be a str")
+        pulumi.set(__self__, "location", location)
+        if project and not isinstance(project, str):
+            raise TypeError("Expected argument 'project' to be a str")
+        pulumi.set(__self__, "project", project)
+        if rules and not isinstance(rules, list):
+            raise TypeError("Expected argument 'rules' to be a list")
+        pulumi.set(__self__, "rules", rules)
+
+    @property
+    @pulumi.getter(name="dataScanId")
+    def data_scan_id(self) -> builtins.str:
+        return pulumi.get(self, "data_scan_id")
+
+    @property
+    @pulumi.getter
+    def id(self) -> builtins.str:
+        """
+        The provider-assigned unique ID for this managed resource.
+        """
+        return pulumi.get(self, "id")
+
+    @property
+    @pulumi.getter
+    def location(self) -> Optional[builtins.str]:
+        return pulumi.get(self, "location")
+
+    @property
+    @pulumi.getter
+    def project(self) -> Optional[builtins.str]:
+        return pulumi.get(self, "project")
+
+    @property
+    @pulumi.getter
+    def rules(self) -> Sequence['outputs.GetDataQualityRulesRuleResult']:
+        """
+        (Computed) The list of generated data quality rules. For more details, please see the datascan page.
+        """
+        return pulumi.get(self, "rules")
+
+
+class AwaitableGetDataQualityRulesResult(GetDataQualityRulesResult):
+    # pylint: disable=using-constant-test
+    def __await__(self):
+        if False:
+            yield self
+        return GetDataQualityRulesResult(
+            data_scan_id=self.data_scan_id,
+            id=self.id,
+            location=self.location,
+            project=self.project,
+            rules=self.rules)
+
+
+def get_data_quality_rules(data_scan_id: Optional[builtins.str] = None,
+                           location: Optional[builtins.str] = None,
+                           project: Optional[builtins.str] = None,
+                           opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetDataQualityRulesResult:
+    """
+    Retrieves the generated data quality rules for the creating a new data quality scan.
+    For more information see
+    the [official documentation](https://cloud.google.com/dataplex/docs)
+    and [API](https://cloud.google.com/dataplex/docs/reference/rest/v1/projects.locations.dataScans/generateDataQualityRules).
+
+    ## example
+
+    ```python
+    import pulumi
+    import pulumi_gcp as gcp
+
+    dqrs = gcp.dataplex.get_data_quality_rules(project="my-project",
+        location="use-central1",
+        data_scan_id="my-datascan-profile")
+    ```
+
+
+    :param builtins.str data_scan_id: The ID of the data profile scan which the generation of quality rules will be basing on.
+    :param builtins.str location: The location where the referenced data profile scan resides.
+    :param builtins.str project: The ID of the project in which the datascan belongs.
+    """
+    __args__ = dict()
+    __args__['dataScanId'] = data_scan_id
+    __args__['location'] = location
+    __args__['project'] = project
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke('gcp:dataplex/getDataQualityRules:getDataQualityRules', __args__, opts=opts, typ=GetDataQualityRulesResult).value
+
+    return AwaitableGetDataQualityRulesResult(
+        data_scan_id=pulumi.get(__ret__, 'data_scan_id'),
+        id=pulumi.get(__ret__, 'id'),
+        location=pulumi.get(__ret__, 'location'),
+        project=pulumi.get(__ret__, 'project'),
+        rules=pulumi.get(__ret__, 'rules'))
+def get_data_quality_rules_output(data_scan_id: Optional[pulumi.Input[builtins.str]] = None,
+                                  location: Optional[pulumi.Input[Optional[builtins.str]]] = None,
+                                  project: Optional[pulumi.Input[Optional[builtins.str]]] = None,
+                                  opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetDataQualityRulesResult]:
+    """
+    Retrieves the generated data quality rules for the creating a new data quality scan.
+    For more information see
+    the [official documentation](https://cloud.google.com/dataplex/docs)
+    and [API](https://cloud.google.com/dataplex/docs/reference/rest/v1/projects.locations.dataScans/generateDataQualityRules).
+
+    ## example
+
+    ```python
+    import pulumi
+    import pulumi_gcp as gcp
+
+    dqrs = gcp.dataplex.get_data_quality_rules(project="my-project",
+        location="use-central1",
+        data_scan_id="my-datascan-profile")
+    ```
+
+
+    :param builtins.str data_scan_id: The ID of the data profile scan which the generation of quality rules will be basing on.
+    :param builtins.str location: The location where the referenced data profile scan resides.
+    :param builtins.str project: The ID of the project in which the datascan belongs.
+    """
+    __args__ = dict()
+    __args__['dataScanId'] = data_scan_id
+    __args__['location'] = location
+    __args__['project'] = project
+    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke_output('gcp:dataplex/getDataQualityRules:getDataQualityRules', __args__, opts=opts, typ=GetDataQualityRulesResult)
+    return __ret__.apply(lambda __response__: GetDataQualityRulesResult(
+        data_scan_id=pulumi.get(__response__, 'data_scan_id'),
+        id=pulumi.get(__response__, 'id'),
+        location=pulumi.get(__response__, 'location'),
+        project=pulumi.get(__response__, 'project'),
+        rules=pulumi.get(__response__, 'rules')))