pulumi-oci 2.5.0a1722062014__py3-none-any.whl → 2.6.0__py3-none-any.whl

pulumi_oci/networkfirewall/__init__.py

@@ -26,6 +26,8 @@ from .get_network_firewall_policy_service import *
 from .get_network_firewall_policy_service_list import *
 from .get_network_firewall_policy_service_lists import *
 from .get_network_firewall_policy_services import *
+from .get_network_firewall_policy_tunnel_inspection_rule import *
+from .get_network_firewall_policy_tunnel_inspection_rules import *
 from .get_network_firewall_policy_url_list import *
 from .get_network_firewall_policy_url_lists import *
 from .get_network_firewalls import *
@@ -40,6 +42,7 @@ from .network_firewall_policy_mapped_secret import *
 from .network_firewall_policy_security_rule import *
 from .network_firewall_policy_service import *
 from .network_firewall_policy_service_list import *
+from .network_firewall_policy_tunnel_inspection_rule import *
 from .network_firewall_policy_url_list import *
 from ._inputs import *
 from . import outputs

pulumi_oci/networkfirewall/_inputs.py

@@ -15,6 +15,9 @@ __all__ = [
     'NetworkFirewallPolicySecurityRuleConditionArgs',
     'NetworkFirewallPolicySecurityRulePositionArgs',
     'NetworkFirewallPolicyServicePortRangeArgs',
+    'NetworkFirewallPolicyTunnelInspectionRuleConditionArgs',
+    'NetworkFirewallPolicyTunnelInspectionRulePositionArgs',
+    'NetworkFirewallPolicyTunnelInspectionRuleProfileArgs',
     'NetworkFirewallPolicyUrlListUrlArgs',
     'GetNetworkFirewallPoliciesFilterArgs',
     'GetNetworkFirewallPolicyAddressListsFilterArgs',
@@ -25,6 +28,7 @@ __all__ = [
     'GetNetworkFirewallPolicySecurityRulesFilterArgs',
     'GetNetworkFirewallPolicyServiceListsFilterArgs',
     'GetNetworkFirewallPolicyServicesFilterArgs',
+    'GetNetworkFirewallPolicyTunnelInspectionRulesFilterArgs',
     'GetNetworkFirewallPolicyUrlListsFilterArgs',
     'GetNetworkFirewallsFilterArgs',
 ]
@@ -287,6 +291,107 @@ class NetworkFirewallPolicyServicePortRangeArgs:
         pulumi.set(self, "maximum_port", value)
 
 
+@pulumi.input_type
+class NetworkFirewallPolicyTunnelInspectionRuleConditionArgs:
+    def __init__(__self__, *,
+                 destination_addresses: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
+                 source_addresses: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
+        """
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] destination_addresses: (Updatable) An array of address list names to be evaluated against the traffic destination address.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] source_addresses: (Updatable) An array of address list names to be evaluated against the traffic source address.
+        """
+        if destination_addresses is not None:
+            pulumi.set(__self__, "destination_addresses", destination_addresses)
+        if source_addresses is not None:
+            pulumi.set(__self__, "source_addresses", source_addresses)
+
+    @property
+    @pulumi.getter(name="destinationAddresses")
+    def destination_addresses(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        (Updatable) An array of address list names to be evaluated against the traffic destination address.
+        """
+        return pulumi.get(self, "destination_addresses")
+
+    @destination_addresses.setter
+    def destination_addresses(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "destination_addresses", value)
+
+    @property
+    @pulumi.getter(name="sourceAddresses")
+    def source_addresses(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        (Updatable) An array of address list names to be evaluated against the traffic source address.
+        """
+        return pulumi.get(self, "source_addresses")
+
+    @source_addresses.setter
+    def source_addresses(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "source_addresses", value)
+
+
+@pulumi.input_type
+class NetworkFirewallPolicyTunnelInspectionRulePositionArgs:
+    def __init__(__self__, *,
+                 after_rule: Optional[pulumi.Input[str]] = None,
+                 before_rule: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[str] after_rule: (Updatable) Identifier for rule after which this rule lies.
+        :param pulumi.Input[str] before_rule: (Updatable) Identifier for rule before which this rule lies.
+        """
+        if after_rule is not None:
+            pulumi.set(__self__, "after_rule", after_rule)
+        if before_rule is not None:
+            pulumi.set(__self__, "before_rule", before_rule)
+
+    @property
+    @pulumi.getter(name="afterRule")
+    def after_rule(self) -> Optional[pulumi.Input[str]]:
+        """
+        (Updatable) Identifier for rule after which this rule lies.
+        """
+        return pulumi.get(self, "after_rule")
+
+    @after_rule.setter
+    def after_rule(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "after_rule", value)
+
+    @property
+    @pulumi.getter(name="beforeRule")
+    def before_rule(self) -> Optional[pulumi.Input[str]]:
+        """
+        (Updatable) Identifier for rule before which this rule lies.
+        """
+        return pulumi.get(self, "before_rule")
+
+    @before_rule.setter
+    def before_rule(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "before_rule", value)
+
+
+@pulumi.input_type
+class NetworkFirewallPolicyTunnelInspectionRuleProfileArgs:
+    def __init__(__self__, *,
+                 must_return_traffic_to_source: Optional[pulumi.Input[bool]] = None):
+        """
+        :param pulumi.Input[bool] must_return_traffic_to_source: (Updatable) Return scanned VXLAN tunnel traffic to source.
+        """
+        if must_return_traffic_to_source is not None:
+            pulumi.set(__self__, "must_return_traffic_to_source", must_return_traffic_to_source)
+
+    @property
+    @pulumi.getter(name="mustReturnTrafficToSource")
+    def must_return_traffic_to_source(self) -> Optional[pulumi.Input[bool]]:
+        """
+        (Updatable) Return scanned VXLAN tunnel traffic to source.
+        """
+        return pulumi.get(self, "must_return_traffic_to_source")
+
+    @must_return_traffic_to_source.setter
+    def must_return_traffic_to_source(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "must_return_traffic_to_source", value)
+
+
 @pulumi.input_type
 class NetworkFirewallPolicyUrlListUrlArgs:
     def __init__(__self__, *,
@@ -733,6 +838,51 @@ class GetNetworkFirewallPolicyServicesFilterArgs:
         pulumi.set(self, "regex", value)
 
 
+@pulumi.input_type
+class GetNetworkFirewallPolicyTunnelInspectionRulesFilterArgs:
+    def __init__(__self__, *,
+                 name: str,
+                 values: Sequence[str],
+                 regex: Optional[bool] = None):
+        """
+        :param str name: Name for the Tunnel Inspection Rule, must be unique within the policy.
+        """
+        pulumi.set(__self__, "name", name)
+        pulumi.set(__self__, "values", values)
+        if regex is not None:
+            pulumi.set(__self__, "regex", regex)
+
+    @property
+    @pulumi.getter
+    def name(self) -> str:
+        """
+        Name for the Tunnel Inspection Rule, must be unique within the policy.
+        """
+        return pulumi.get(self, "name")
+
+    @name.setter
+    def name(self, value: str):
+        pulumi.set(self, "name", value)
+
+    @property
+    @pulumi.getter
+    def values(self) -> Sequence[str]:
+        return pulumi.get(self, "values")
+
+    @values.setter
+    def values(self, value: Sequence[str]):
+        pulumi.set(self, "values", value)
+
+    @property
+    @pulumi.getter
+    def regex(self) -> Optional[bool]:
+        return pulumi.get(self, "regex")
+
+    @regex.setter
+    def regex(self, value: Optional[bool]):
+        pulumi.set(self, "regex", value)
+
+
 @pulumi.input_type
 class GetNetworkFirewallPolicyUrlListsFilterArgs:
     def __init__(__self__, *,

pulumi_oci/networkfirewall/get_network_firewall_policy_tunnel_inspection_rule.py

@@ -0,0 +1,227 @@
+# 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 pulumi
+import pulumi.runtime
+from typing import Any, Mapping, Optional, Sequence, Union, overload
+from .. import _utilities
+from . import outputs
+
+__all__ = [
+    'GetNetworkFirewallPolicyTunnelInspectionRuleResult',
+    'AwaitableGetNetworkFirewallPolicyTunnelInspectionRuleResult',
+    'get_network_firewall_policy_tunnel_inspection_rule',
+    'get_network_firewall_policy_tunnel_inspection_rule_output',
+]
+
+@pulumi.output_type
+class GetNetworkFirewallPolicyTunnelInspectionRuleResult:
+    """
+    A collection of values returned by getNetworkFirewallPolicyTunnelInspectionRule.
+    """
+    def __init__(__self__, action=None, conditions=None, id=None, name=None, network_firewall_policy_id=None, parent_resource_id=None, positions=None, priority_order=None, profiles=None, protocol=None, tunnel_inspection_rule_name=None):
+        if action and not isinstance(action, str):
+            raise TypeError("Expected argument 'action' to be a str")
+        pulumi.set(__self__, "action", action)
+        if conditions and not isinstance(conditions, list):
+            raise TypeError("Expected argument 'conditions' to be a list")
+        pulumi.set(__self__, "conditions", conditions)
+        if id and not isinstance(id, str):
+            raise TypeError("Expected argument 'id' to be a str")
+        pulumi.set(__self__, "id", id)
+        if name and not isinstance(name, str):
+            raise TypeError("Expected argument 'name' to be a str")
+        pulumi.set(__self__, "name", name)
+        if network_firewall_policy_id and not isinstance(network_firewall_policy_id, str):
+            raise TypeError("Expected argument 'network_firewall_policy_id' to be a str")
+        pulumi.set(__self__, "network_firewall_policy_id", network_firewall_policy_id)
+        if parent_resource_id and not isinstance(parent_resource_id, str):
+            raise TypeError("Expected argument 'parent_resource_id' to be a str")
+        pulumi.set(__self__, "parent_resource_id", parent_resource_id)
+        if positions and not isinstance(positions, list):
+            raise TypeError("Expected argument 'positions' to be a list")
+        pulumi.set(__self__, "positions", positions)
+        if priority_order and not isinstance(priority_order, str):
+            raise TypeError("Expected argument 'priority_order' to be a str")
+        pulumi.set(__self__, "priority_order", priority_order)
+        if profiles and not isinstance(profiles, list):
+            raise TypeError("Expected argument 'profiles' to be a list")
+        pulumi.set(__self__, "profiles", profiles)
+        if protocol and not isinstance(protocol, str):
+            raise TypeError("Expected argument 'protocol' to be a str")
+        pulumi.set(__self__, "protocol", protocol)
+        if tunnel_inspection_rule_name and not isinstance(tunnel_inspection_rule_name, str):
+            raise TypeError("Expected argument 'tunnel_inspection_rule_name' to be a str")
+        pulumi.set(__self__, "tunnel_inspection_rule_name", tunnel_inspection_rule_name)
+
+    @property
+    @pulumi.getter
+    def action(self) -> str:
+        """
+        Types of Inspect Action on the Traffic flow.
+        * INSPECT - Inspect the traffic.
+        * INSPECT_AND_CAPTURE_LOG - Inspect and capture logs for the traffic.
+        """
+        return pulumi.get(self, "action")
+
+    @property
+    @pulumi.getter
+    def conditions(self) -> Sequence['outputs.GetNetworkFirewallPolicyTunnelInspectionRuleConditionResult']:
+        """
+        Criteria to evaluate against incoming network traffic. A match occurs when at least one item in the array associated with each specified property corresponds with the relevant aspect of the traffic.
+        """
+        return pulumi.get(self, "conditions")
+
+    @property
+    @pulumi.getter
+    def id(self) -> str:
+        return pulumi.get(self, "id")
+
+    @property
+    @pulumi.getter
+    def name(self) -> str:
+        """
+        Name for the Tunnel Inspection Rule, must be unique within the policy.
+        """
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter(name="networkFirewallPolicyId")
+    def network_firewall_policy_id(self) -> str:
+        return pulumi.get(self, "network_firewall_policy_id")
+
+    @property
+    @pulumi.getter(name="parentResourceId")
+    def parent_resource_id(self) -> str:
+        """
+        OCID of the Network Firewall Policy this Tunnel Inspection Rule belongs to.
+        """
+        return pulumi.get(self, "parent_resource_id")
+
+    @property
+    @pulumi.getter
+    def positions(self) -> Sequence['outputs.GetNetworkFirewallPolicyTunnelInspectionRulePositionResult']:
+        """
+        An object which defines the position of the rule.
+        """
+        return pulumi.get(self, "positions")
+
+    @property
+    @pulumi.getter(name="priorityOrder")
+    def priority_order(self) -> str:
+        """
+        The priority order in which this rule should be evaluated
+        """
+        return pulumi.get(self, "priority_order")
+
+    @property
+    @pulumi.getter
+    def profiles(self) -> Sequence['outputs.GetNetworkFirewallPolicyTunnelInspectionRuleProfileResult']:
+        """
+        Vxlan Inspect profile used in Vxlan Tunnel Inspection Rules.
+        """
+        return pulumi.get(self, "profiles")
+
+    @property
+    @pulumi.getter
+    def protocol(self) -> str:
+        """
+        Types of Tunnel Inspection Protocol to be applied on the traffic.
+        * VXLAN - VXLAN Tunnel Inspection Protocol will be applied on the traffic.
+        """
+        return pulumi.get(self, "protocol")
+
+    @property
+    @pulumi.getter(name="tunnelInspectionRuleName")
+    def tunnel_inspection_rule_name(self) -> str:
+        return pulumi.get(self, "tunnel_inspection_rule_name")
+
+
+class AwaitableGetNetworkFirewallPolicyTunnelInspectionRuleResult(GetNetworkFirewallPolicyTunnelInspectionRuleResult):
+    # pylint: disable=using-constant-test
+    def __await__(self):
+        if False:
+            yield self
+        return GetNetworkFirewallPolicyTunnelInspectionRuleResult(
+            action=self.action,
+            conditions=self.conditions,
+            id=self.id,
+            name=self.name,
+            network_firewall_policy_id=self.network_firewall_policy_id,
+            parent_resource_id=self.parent_resource_id,
+            positions=self.positions,
+            priority_order=self.priority_order,
+            profiles=self.profiles,
+            protocol=self.protocol,
+            tunnel_inspection_rule_name=self.tunnel_inspection_rule_name)
+
+
+def get_network_firewall_policy_tunnel_inspection_rule(network_firewall_policy_id: Optional[str] = None,
+                                                       tunnel_inspection_rule_name: Optional[str] = None,
+                                                       opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetNetworkFirewallPolicyTunnelInspectionRuleResult:
+    """
+    This data source provides details about a specific Network Firewall Policy Tunnel Inspection Rule resource in Oracle Cloud Infrastructure Network Firewall service.
+
+    Get tunnel inspection rule by the given name in the context of network firewall policy.
+
+    ## Example Usage
+
+    ```python
+    import pulumi
+    import pulumi_oci as oci
+
+    test_network_firewall_policy_tunnel_inspection_rule = oci.NetworkFirewall.get_network_firewall_policy_tunnel_inspection_rule(network_firewall_policy_id=test_network_firewall_policy["id"],
+        tunnel_inspection_rule_name=test_rule["name"])
+    ```
+
+
+    :param str network_firewall_policy_id: Unique Network Firewall Policy identifier
+    :param str tunnel_inspection_rule_name: Unique identifier for Tunnel Inspection Rules in the network firewall policy.
+    """
+    __args__ = dict()
+    __args__['networkFirewallPolicyId'] = network_firewall_policy_id
+    __args__['tunnelInspectionRuleName'] = tunnel_inspection_rule_name
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke('oci:NetworkFirewall/getNetworkFirewallPolicyTunnelInspectionRule:getNetworkFirewallPolicyTunnelInspectionRule', __args__, opts=opts, typ=GetNetworkFirewallPolicyTunnelInspectionRuleResult).value
+
+    return AwaitableGetNetworkFirewallPolicyTunnelInspectionRuleResult(
+        action=pulumi.get(__ret__, 'action'),
+        conditions=pulumi.get(__ret__, 'conditions'),
+        id=pulumi.get(__ret__, 'id'),
+        name=pulumi.get(__ret__, 'name'),
+        network_firewall_policy_id=pulumi.get(__ret__, 'network_firewall_policy_id'),
+        parent_resource_id=pulumi.get(__ret__, 'parent_resource_id'),
+        positions=pulumi.get(__ret__, 'positions'),
+        priority_order=pulumi.get(__ret__, 'priority_order'),
+        profiles=pulumi.get(__ret__, 'profiles'),
+        protocol=pulumi.get(__ret__, 'protocol'),
+        tunnel_inspection_rule_name=pulumi.get(__ret__, 'tunnel_inspection_rule_name'))
+
+
+@_utilities.lift_output_func(get_network_firewall_policy_tunnel_inspection_rule)
+def get_network_firewall_policy_tunnel_inspection_rule_output(network_firewall_policy_id: Optional[pulumi.Input[str]] = None,
+                                                              tunnel_inspection_rule_name: Optional[pulumi.Input[str]] = None,
+                                                              opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetNetworkFirewallPolicyTunnelInspectionRuleResult]:
+    """
+    This data source provides details about a specific Network Firewall Policy Tunnel Inspection Rule resource in Oracle Cloud Infrastructure Network Firewall service.
+
+    Get tunnel inspection rule by the given name in the context of network firewall policy.
+
+    ## Example Usage
+
+    ```python
+    import pulumi
+    import pulumi_oci as oci
+
+    test_network_firewall_policy_tunnel_inspection_rule = oci.NetworkFirewall.get_network_firewall_policy_tunnel_inspection_rule(network_firewall_policy_id=test_network_firewall_policy["id"],
+        tunnel_inspection_rule_name=test_rule["name"])
+    ```
+
+
+    :param str network_firewall_policy_id: Unique Network Firewall Policy identifier
+    :param str tunnel_inspection_rule_name: Unique identifier for Tunnel Inspection Rules in the network firewall policy.
+    """
+    ...

pulumi_oci/networkfirewall/get_network_firewall_policy_tunnel_inspection_rules.py

@@ -0,0 +1,167 @@
+# 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 pulumi
+import pulumi.runtime
+from typing import Any, Mapping, Optional, Sequence, Union, overload
+from .. import _utilities
+from . import outputs
+from ._inputs import *
+
+__all__ = [
+    'GetNetworkFirewallPolicyTunnelInspectionRulesResult',
+    'AwaitableGetNetworkFirewallPolicyTunnelInspectionRulesResult',
+    'get_network_firewall_policy_tunnel_inspection_rules',
+    'get_network_firewall_policy_tunnel_inspection_rules_output',
+]
+
+@pulumi.output_type
+class GetNetworkFirewallPolicyTunnelInspectionRulesResult:
+    """
+    A collection of values returned by getNetworkFirewallPolicyTunnelInspectionRules.
+    """
+    def __init__(__self__, display_name=None, filters=None, id=None, network_firewall_policy_id=None, tunnel_inspection_rule_priority_order=None, tunnel_inspection_rule_summary_collections=None):
+        if display_name and not isinstance(display_name, str):
+            raise TypeError("Expected argument 'display_name' to be a str")
+        pulumi.set(__self__, "display_name", display_name)
+        if filters and not isinstance(filters, list):
+            raise TypeError("Expected argument 'filters' to be a list")
+        pulumi.set(__self__, "filters", filters)
+        if id and not isinstance(id, str):
+            raise TypeError("Expected argument 'id' to be a str")
+        pulumi.set(__self__, "id", id)
+        if network_firewall_policy_id and not isinstance(network_firewall_policy_id, str):
+            raise TypeError("Expected argument 'network_firewall_policy_id' to be a str")
+        pulumi.set(__self__, "network_firewall_policy_id", network_firewall_policy_id)
+        if tunnel_inspection_rule_priority_order and not isinstance(tunnel_inspection_rule_priority_order, int):
+            raise TypeError("Expected argument 'tunnel_inspection_rule_priority_order' to be a int")
+        pulumi.set(__self__, "tunnel_inspection_rule_priority_order", tunnel_inspection_rule_priority_order)
+        if tunnel_inspection_rule_summary_collections and not isinstance(tunnel_inspection_rule_summary_collections, list):
+            raise TypeError("Expected argument 'tunnel_inspection_rule_summary_collections' to be a list")
+        pulumi.set(__self__, "tunnel_inspection_rule_summary_collections", tunnel_inspection_rule_summary_collections)
+
+    @property
+    @pulumi.getter(name="displayName")
+    def display_name(self) -> Optional[str]:
+        return pulumi.get(self, "display_name")
+
+    @property
+    @pulumi.getter
+    def filters(self) -> Optional[Sequence['outputs.GetNetworkFirewallPolicyTunnelInspectionRulesFilterResult']]:
+        return pulumi.get(self, "filters")
+
+    @property
+    @pulumi.getter
+    def id(self) -> str:
+        """
+        The provider-assigned unique ID for this managed resource.
+        """
+        return pulumi.get(self, "id")
+
+    @property
+    @pulumi.getter(name="networkFirewallPolicyId")
+    def network_firewall_policy_id(self) -> str:
+        return pulumi.get(self, "network_firewall_policy_id")
+
+    @property
+    @pulumi.getter(name="tunnelInspectionRulePriorityOrder")
+    def tunnel_inspection_rule_priority_order(self) -> Optional[int]:
+        return pulumi.get(self, "tunnel_inspection_rule_priority_order")
+
+    @property
+    @pulumi.getter(name="tunnelInspectionRuleSummaryCollections")
+    def tunnel_inspection_rule_summary_collections(self) -> Sequence['outputs.GetNetworkFirewallPolicyTunnelInspectionRulesTunnelInspectionRuleSummaryCollectionResult']:
+        """
+        The list of tunnel_inspection_rule_summary_collection.
+        """
+        return pulumi.get(self, "tunnel_inspection_rule_summary_collections")
+
+
+class AwaitableGetNetworkFirewallPolicyTunnelInspectionRulesResult(GetNetworkFirewallPolicyTunnelInspectionRulesResult):
+    # pylint: disable=using-constant-test
+    def __await__(self):
+        if False:
+            yield self
+        return GetNetworkFirewallPolicyTunnelInspectionRulesResult(
+            display_name=self.display_name,
+            filters=self.filters,
+            id=self.id,
+            network_firewall_policy_id=self.network_firewall_policy_id,
+            tunnel_inspection_rule_priority_order=self.tunnel_inspection_rule_priority_order,
+            tunnel_inspection_rule_summary_collections=self.tunnel_inspection_rule_summary_collections)
+
+
+def get_network_firewall_policy_tunnel_inspection_rules(display_name: Optional[str] = None,
+                                                        filters: Optional[Sequence[pulumi.InputType['GetNetworkFirewallPolicyTunnelInspectionRulesFilterArgs']]] = None,
+                                                        network_firewall_policy_id: Optional[str] = None,
+                                                        tunnel_inspection_rule_priority_order: Optional[int] = None,
+                                                        opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetNetworkFirewallPolicyTunnelInspectionRulesResult:
+    """
+    This data source provides the list of Network Firewall Policy Tunnel Inspection Rules in Oracle Cloud Infrastructure Network Firewall service.
+
+    Returns a list of tunnel inspection rules for the network firewall policy.
+
+    ## Example Usage
+
+    ```python
+    import pulumi
+    import pulumi_oci as oci
+
+    test_network_firewall_policy_tunnel_inspection_rules = oci.NetworkFirewall.get_network_firewall_policy_tunnel_inspection_rules(network_firewall_policy_id=test_network_firewall_policy["id"],
+        display_name=network_firewall_policy_tunnel_inspection_rule_display_name,
+        tunnel_inspection_rule_priority_order=network_firewall_policy_tunnel_inspection_rule_tunnel_inspection_rule_priority_order)
+    ```
+
+
+    :param str display_name: A filter to return only resources that match the entire display name given.
+    :param str network_firewall_policy_id: Unique Network Firewall Policy identifier
+    :param int tunnel_inspection_rule_priority_order: Unique priority order for Tunnel Inspection rules in the network firewall policy.
+    """
+    __args__ = dict()
+    __args__['displayName'] = display_name
+    __args__['filters'] = filters
+    __args__['networkFirewallPolicyId'] = network_firewall_policy_id
+    __args__['tunnelInspectionRulePriorityOrder'] = tunnel_inspection_rule_priority_order
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke('oci:NetworkFirewall/getNetworkFirewallPolicyTunnelInspectionRules:getNetworkFirewallPolicyTunnelInspectionRules', __args__, opts=opts, typ=GetNetworkFirewallPolicyTunnelInspectionRulesResult).value
+
+    return AwaitableGetNetworkFirewallPolicyTunnelInspectionRulesResult(
+        display_name=pulumi.get(__ret__, 'display_name'),
+        filters=pulumi.get(__ret__, 'filters'),
+        id=pulumi.get(__ret__, 'id'),
+        network_firewall_policy_id=pulumi.get(__ret__, 'network_firewall_policy_id'),
+        tunnel_inspection_rule_priority_order=pulumi.get(__ret__, 'tunnel_inspection_rule_priority_order'),
+        tunnel_inspection_rule_summary_collections=pulumi.get(__ret__, 'tunnel_inspection_rule_summary_collections'))
+
+
+@_utilities.lift_output_func(get_network_firewall_policy_tunnel_inspection_rules)
+def get_network_firewall_policy_tunnel_inspection_rules_output(display_name: Optional[pulumi.Input[Optional[str]]] = None,
+                                                               filters: Optional[pulumi.Input[Optional[Sequence[pulumi.InputType['GetNetworkFirewallPolicyTunnelInspectionRulesFilterArgs']]]]] = None,
+                                                               network_firewall_policy_id: Optional[pulumi.Input[str]] = None,
+                                                               tunnel_inspection_rule_priority_order: Optional[pulumi.Input[Optional[int]]] = None,
+                                                               opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetNetworkFirewallPolicyTunnelInspectionRulesResult]:
+    """
+    This data source provides the list of Network Firewall Policy Tunnel Inspection Rules in Oracle Cloud Infrastructure Network Firewall service.
+
+    Returns a list of tunnel inspection rules for the network firewall policy.
+
+    ## Example Usage
+
+    ```python
+    import pulumi
+    import pulumi_oci as oci
+
+    test_network_firewall_policy_tunnel_inspection_rules = oci.NetworkFirewall.get_network_firewall_policy_tunnel_inspection_rules(network_firewall_policy_id=test_network_firewall_policy["id"],
+        display_name=network_firewall_policy_tunnel_inspection_rule_display_name,
+        tunnel_inspection_rule_priority_order=network_firewall_policy_tunnel_inspection_rule_tunnel_inspection_rule_priority_order)
+    ```
+
+
+    :param str display_name: A filter to return only resources that match the entire display name given.
+    :param str network_firewall_policy_id: Unique Network Firewall Policy identifier
+    :param int tunnel_inspection_rule_priority_order: Unique priority order for Tunnel Inspection rules in the network firewall policy.
+    """
+    ...