gcp.compute.NetworkFirewallPolicyRule

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";

const basicGlobalNetworksecurityAddressGroup = new gcp.networksecurity.AddressGroup("basic_global_networksecurity_address_group", {
    name: "address",
    parent: "projects/my-project-name",
    description: "Sample global networksecurity_address_group",
    location: "global",
    items: ["208.80.154.224/32"],
    type: "IPV4",
    capacity: 100,
});
const basicNetworkFirewallPolicy = new gcp.compute.NetworkFirewallPolicy("basic_network_firewall_policy", {
    name: "policy",
    description: "Sample global network firewall policy",
    project: "my-project-name",
});
const basicNetwork = new gcp.compute.Network("basic_network", {name: "network"});
const basicKey = new gcp.tags.TagKey("basic_key", {
    description: "For keyname resources.",
    parent: "organizations/123456789",
    purpose: "GCE_FIREWALL",
    shortName: "tagkey",
    purposeData: {
        network: pulumi.interpolate`my-project-name/${basicNetwork.name}`,
    },
});
const basicValue = new gcp.tags.TagValue("basic_value", {
    description: "For valuename resources.",
    parent: basicKey.id,
    shortName: "tagvalue",
});
const primary = new gcp.compute.NetworkFirewallPolicyRule("primary", {
    action: "allow",
    description: "This is a simple rule description",
    direction: "INGRESS",
    disabled: false,
    enableLogging: true,
    firewallPolicy: basicNetworkFirewallPolicy.name,
    priority: 1000,
    ruleName: "test-rule",
    targetServiceAccounts: ["my@service-account.com"],
    match: {
        srcIpRanges: ["10.100.0.1/32"],
        srcFqdns: ["google.com"],
        srcRegionCodes: ["US"],
        srcThreatIntelligences: ["iplist-known-malicious-ips"],
        srcSecureTags: [{
            name: basicValue.id,
        }],
        layer4Configs: [{
            ipProtocol: "all",
        }],
        srcAddressGroups: [basicGlobalNetworksecurityAddressGroup.id],
    },
});

import pulumi
import pulumi_gcp as gcp

basic_global_networksecurity_address_group = gcp.networksecurity.AddressGroup("basic_global_networksecurity_address_group",
    name="address",
    parent="projects/my-project-name",
    description="Sample global networksecurity_address_group",
    location="global",
    items=["208.80.154.224/32"],
    type="IPV4",
    capacity=100)
basic_network_firewall_policy = gcp.compute.NetworkFirewallPolicy("basic_network_firewall_policy",
    name="policy",
    description="Sample global network firewall policy",
    project="my-project-name")
basic_network = gcp.compute.Network("basic_network", name="network")
basic_key = gcp.tags.TagKey("basic_key",
    description="For keyname resources.",
    parent="organizations/123456789",
    purpose="GCE_FIREWALL",
    short_name="tagkey",
    purpose_data={
        "network": basic_network.name.apply(lambda name: f"my-project-name/{name}"),
    })
basic_value = gcp.tags.TagValue("basic_value",
    description="For valuename resources.",
    parent=basic_key.id,
    short_name="tagvalue")
primary = gcp.compute.NetworkFirewallPolicyRule("primary",
    action="allow",
    description="This is a simple rule description",
    direction="INGRESS",
    disabled=False,
    enable_logging=True,
    firewall_policy=basic_network_firewall_policy.name,
    priority=1000,
    rule_name="test-rule",
    target_service_accounts=["my@service-account.com"],
    match={
        "src_ip_ranges": ["10.100.0.1/32"],
        "src_fqdns": ["google.com"],
        "src_region_codes": ["US"],
        "src_threat_intelligences": ["iplist-known-malicious-ips"],
        "src_secure_tags": [{
            "name": basic_value.id,
        }],
        "layer4_configs": [{
            "ip_protocol": "all",
        }],
        "src_address_groups": [basic_global_networksecurity_address_group.id],
    })

package main

import (
	"fmt"

	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/compute"
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/networksecurity"
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/tags"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		basicGlobalNetworksecurityAddressGroup, err := networksecurity.NewAddressGroup(ctx, "basic_global_networksecurity_address_group", &networksecurity.AddressGroupArgs{
			Name:        pulumi.String("address"),
			Parent:      pulumi.String("projects/my-project-name"),
			Description: pulumi.String("Sample global networksecurity_address_group"),
			Location:    pulumi.String("global"),
			Items: pulumi.StringArray{
				pulumi.String("208.80.154.224/32"),
			},
			Type:     pulumi.String("IPV4"),
			Capacity: pulumi.Int(100),
		})
		if err != nil {
			return err
		}
		basicNetworkFirewallPolicy, err := compute.NewNetworkFirewallPolicy(ctx, "basic_network_firewall_policy", &compute.NetworkFirewallPolicyArgs{
			Name:        pulumi.String("policy"),
			Description: pulumi.String("Sample global network firewall policy"),
			Project:     pulumi.String("my-project-name"),
		})
		if err != nil {
			return err
		}
		basicNetwork, err := compute.NewNetwork(ctx, "basic_network", &compute.NetworkArgs{
			Name: pulumi.String("network"),
		})
		if err != nil {
			return err
		}
		basicKey, err := tags.NewTagKey(ctx, "basic_key", &tags.TagKeyArgs{
			Description: pulumi.String("For keyname resources."),
			Parent:      pulumi.String("organizations/123456789"),
			Purpose:     pulumi.String("GCE_FIREWALL"),
			ShortName:   pulumi.String("tagkey"),
			PurposeData: pulumi.StringMap{
				"network": basicNetwork.Name.ApplyT(func(name string) (string, error) {
					return fmt.Sprintf("my-project-name/%v", name), nil
				}).(pulumi.StringOutput),
			},
		})
		if err != nil {
			return err
		}
		basicValue, err := tags.NewTagValue(ctx, "basic_value", &tags.TagValueArgs{
			Description: pulumi.String("For valuename resources."),
			Parent:      basicKey.ID(),
			ShortName:   pulumi.String("tagvalue"),
		})
		if err != nil {
			return err
		}
		_, err = compute.NewNetworkFirewallPolicyRule(ctx, "primary", &compute.NetworkFirewallPolicyRuleArgs{
			Action:         pulumi.String("allow"),
			Description:    pulumi.String("This is a simple rule description"),
			Direction:      pulumi.String("INGRESS"),
			Disabled:       pulumi.Bool(false),
			EnableLogging:  pulumi.Bool(true),
			FirewallPolicy: basicNetworkFirewallPolicy.Name,
			Priority:       pulumi.Int(1000),
			RuleName:       pulumi.String("test-rule"),
			TargetServiceAccounts: pulumi.StringArray{
				pulumi.String("my@service-account.com"),
			},
			Match: &compute.NetworkFirewallPolicyRuleMatchArgs{
				SrcIpRanges: pulumi.StringArray{
					pulumi.String("10.100.0.1/32"),
				},
				SrcFqdns: pulumi.StringArray{
					pulumi.String("google.com"),
				},
				SrcRegionCodes: pulumi.StringArray{
					pulumi.String("US"),
				},
				SrcThreatIntelligences: pulumi.StringArray{
					pulumi.String("iplist-known-malicious-ips"),
				},
				SrcSecureTags: compute.NetworkFirewallPolicyRuleMatchSrcSecureTagArray{
					&compute.NetworkFirewallPolicyRuleMatchSrcSecureTagArgs{
						Name: basicValue.ID(),
					},
				},
				Layer4Configs: compute.NetworkFirewallPolicyRuleMatchLayer4ConfigArray{
					&compute.NetworkFirewallPolicyRuleMatchLayer4ConfigArgs{
						IpProtocol: pulumi.String("all"),
					},
				},
				SrcAddressGroups: pulumi.StringArray{
					basicGlobalNetworksecurityAddressGroup.ID(),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;

return await Deployment.RunAsync(() => 
{
    var basicGlobalNetworksecurityAddressGroup = new Gcp.NetworkSecurity.AddressGroup("basic_global_networksecurity_address_group", new()
    {
        Name = "address",
        Parent = "projects/my-project-name",
        Description = "Sample global networksecurity_address_group",
        Location = "global",
        Items = new[]
        {
            "208.80.154.224/32",
        },
        Type = "IPV4",
        Capacity = 100,
    });

    var basicNetworkFirewallPolicy = new Gcp.Compute.NetworkFirewallPolicy("basic_network_firewall_policy", new()
    {
        Name = "policy",
        Description = "Sample global network firewall policy",
        Project = "my-project-name",
    });

    var basicNetwork = new Gcp.Compute.Network("basic_network", new()
    {
        Name = "network",
    });

    var basicKey = new Gcp.Tags.TagKey("basic_key", new()
    {
        Description = "For keyname resources.",
        Parent = "organizations/123456789",
        Purpose = "GCE_FIREWALL",
        ShortName = "tagkey",
        PurposeData = 
        {
            { "network", basicNetwork.Name.Apply(name => $"my-project-name/{name}") },
        },
    });

    var basicValue = new Gcp.Tags.TagValue("basic_value", new()
    {
        Description = "For valuename resources.",
        Parent = basicKey.Id,
        ShortName = "tagvalue",
    });

    var primary = new Gcp.Compute.NetworkFirewallPolicyRule("primary", new()
    {
        Action = "allow",
        Description = "This is a simple rule description",
        Direction = "INGRESS",
        Disabled = false,
        EnableLogging = true,
        FirewallPolicy = basicNetworkFirewallPolicy.Name,
        Priority = 1000,
        RuleName = "test-rule",
        TargetServiceAccounts = new[]
        {
            "my@service-account.com",
        },
        Match = new Gcp.Compute.Inputs.NetworkFirewallPolicyRuleMatchArgs
        {
            SrcIpRanges = new[]
            {
                "10.100.0.1/32",
            },
            SrcFqdns = new[]
            {
                "google.com",
            },
            SrcRegionCodes = new[]
            {
                "US",
            },
            SrcThreatIntelligences = new[]
            {
                "iplist-known-malicious-ips",
            },
            SrcSecureTags = new[]
            {
                new Gcp.Compute.Inputs.NetworkFirewallPolicyRuleMatchSrcSecureTagArgs
                {
                    Name = basicValue.Id,
                },
            },
            Layer4Configs = new[]
            {
                new Gcp.Compute.Inputs.NetworkFirewallPolicyRuleMatchLayer4ConfigArgs
                {
                    IpProtocol = "all",
                },
            },
            SrcAddressGroups = new[]
            {
                basicGlobalNetworksecurityAddressGroup.Id,
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.networksecurity.AddressGroup;
import com.pulumi.gcp.networksecurity.AddressGroupArgs;
import com.pulumi.gcp.compute.NetworkFirewallPolicy;
import com.pulumi.gcp.compute.NetworkFirewallPolicyArgs;
import com.pulumi.gcp.compute.Network;
import com.pulumi.gcp.compute.NetworkArgs;
import com.pulumi.gcp.tags.TagKey;
import com.pulumi.gcp.tags.TagKeyArgs;
import com.pulumi.gcp.tags.TagValue;
import com.pulumi.gcp.tags.TagValueArgs;
import com.pulumi.gcp.compute.NetworkFirewallPolicyRule;
import com.pulumi.gcp.compute.NetworkFirewallPolicyRuleArgs;
import com.pulumi.gcp.compute.inputs.NetworkFirewallPolicyRuleMatchArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var basicGlobalNetworksecurityAddressGroup = new AddressGroup("basicGlobalNetworksecurityAddressGroup", AddressGroupArgs.builder()
            .name("address")
            .parent("projects/my-project-name")
            .description("Sample global networksecurity_address_group")
            .location("global")
            .items("208.80.154.224/32")
            .type("IPV4")
            .capacity(100)
            .build());

        var basicNetworkFirewallPolicy = new NetworkFirewallPolicy("basicNetworkFirewallPolicy", NetworkFirewallPolicyArgs.builder()
            .name("policy")
            .description("Sample global network firewall policy")
            .project("my-project-name")
            .build());

        var basicNetwork = new Network("basicNetwork", NetworkArgs.builder()
            .name("network")
            .build());

        var basicKey = new TagKey("basicKey", TagKeyArgs.builder()
            .description("For keyname resources.")
            .parent("organizations/123456789")
            .purpose("GCE_FIREWALL")
            .shortName("tagkey")
            .purposeData(Map.of("network", basicNetwork.name().applyValue(name -> String.format("my-project-name/%s", name))))
            .build());

        var basicValue = new TagValue("basicValue", TagValueArgs.builder()
            .description("For valuename resources.")
            .parent(basicKey.id())
            .shortName("tagvalue")
            .build());

        var primary = new NetworkFirewallPolicyRule("primary", NetworkFirewallPolicyRuleArgs.builder()
            .action("allow")
            .description("This is a simple rule description")
            .direction("INGRESS")
            .disabled(false)
            .enableLogging(true)
            .firewallPolicy(basicNetworkFirewallPolicy.name())
            .priority(1000)
            .ruleName("test-rule")
            .targetServiceAccounts("my@service-account.com")
            .match(NetworkFirewallPolicyRuleMatchArgs.builder()
                .srcIpRanges("10.100.0.1/32")
                .srcFqdns("google.com")
                .srcRegionCodes("US")
                .srcThreatIntelligences("iplist-known-malicious-ips")
                .srcSecureTags(NetworkFirewallPolicyRuleMatchSrcSecureTagArgs.builder()
                    .name(basicValue.id())
                    .build())
                .layer4Configs(NetworkFirewallPolicyRuleMatchLayer4ConfigArgs.builder()
                    .ipProtocol("all")
                    .build())
                .srcAddressGroups(basicGlobalNetworksecurityAddressGroup.id())
                .build())
            .build());

    }
}

resources:
  basicGlobalNetworksecurityAddressGroup:
    type: gcp:networksecurity:AddressGroup
    name: basic_global_networksecurity_address_group
    properties:
      name: address
      parent: projects/my-project-name
      description: Sample global networksecurity_address_group
      location: global
      items:
        - 208.80.154.224/32
      type: IPV4
      capacity: 100
  basicNetworkFirewallPolicy:
    type: gcp:compute:NetworkFirewallPolicy
    name: basic_network_firewall_policy
    properties:
      name: policy
      description: Sample global network firewall policy
      project: my-project-name
  primary:
    type: gcp:compute:NetworkFirewallPolicyRule
    properties:
      action: allow
      description: This is a simple rule description
      direction: INGRESS
      disabled: false
      enableLogging: true
      firewallPolicy: ${basicNetworkFirewallPolicy.name}
      priority: 1000
      ruleName: test-rule
      targetServiceAccounts:
        - my@service-account.com
      match:
        srcIpRanges:
          - 10.100.0.1/32
        srcFqdns:
          - google.com
        srcRegionCodes:
          - US
        srcThreatIntelligences:
          - iplist-known-malicious-ips
        srcSecureTags:
          - name: ${basicValue.id}
        layer4Configs:
          - ipProtocol: all
        srcAddressGroups:
          - ${basicGlobalNetworksecurityAddressGroup.id}
  basicNetwork:
    type: gcp:compute:Network
    name: basic_network
    properties:
      name: network
  basicKey:
    type: gcp:tags:TagKey
    name: basic_key
    properties:
      description: For keyname resources.
      parent: organizations/123456789
      purpose: GCE_FIREWALL
      shortName: tagkey
      purposeData:
        network: my-project-name/${basicNetwork.name}
  basicValue:
    type: gcp:tags:TagValue
    name: basic_value
    properties:
      description: For valuename resources.
      parent: ${basicKey.id}
      shortName: tagvalue

var networkFirewallPolicyRuleResource = new Gcp.Compute.NetworkFirewallPolicyRule("networkFirewallPolicyRuleResource", new()
{
    FirewallPolicy = "string",
    Priority = 0,
    Direction = "string",
    Action = "string",
    Match = new Gcp.Compute.Inputs.NetworkFirewallPolicyRuleMatchArgs
    {
        Layer4Configs = new[]
        {
            new Gcp.Compute.Inputs.NetworkFirewallPolicyRuleMatchLayer4ConfigArgs
            {
                IpProtocol = "string",
                Ports = new[]
                {
                    "string",
                },
            },
        },
        DestAddressGroups = new[]
        {
            "string",
        },
        DestFqdns = new[]
        {
            "string",
        },
        DestIpRanges = new[]
        {
            "string",
        },
        DestRegionCodes = new[]
        {
            "string",
        },
        DestThreatIntelligences = new[]
        {
            "string",
        },
        SrcAddressGroups = new[]
        {
            "string",
        },
        SrcFqdns = new[]
        {
            "string",
        },
        SrcIpRanges = new[]
        {
            "string",
        },
        SrcRegionCodes = new[]
        {
            "string",
        },
        SrcSecureTags = new[]
        {
            new Gcp.Compute.Inputs.NetworkFirewallPolicyRuleMatchSrcSecureTagArgs
            {
                Name = "string",
                State = "string",
            },
        },
        SrcThreatIntelligences = new[]
        {
            "string",
        },
    },
    Disabled = false,
    EnableLogging = false,
    Description = "string",
    Project = "string",
    RuleName = "string",
    SecurityProfileGroup = "string",
    TargetSecureTags = new[]
    {
        new Gcp.Compute.Inputs.NetworkFirewallPolicyRuleTargetSecureTagArgs
        {
            Name = "string",
            State = "string",
        },
    },
    TargetServiceAccounts = new[]
    {
        "string",
    },
    TlsInspect = false,
});

example, err := compute.NewNetworkFirewallPolicyRule(ctx, "networkFirewallPolicyRuleResource", &compute.NetworkFirewallPolicyRuleArgs{
	FirewallPolicy: pulumi.String("string"),
	Priority:       pulumi.Int(0),
	Direction:      pulumi.String("string"),
	Action:         pulumi.String("string"),
	Match: &compute.NetworkFirewallPolicyRuleMatchArgs{
		Layer4Configs: compute.NetworkFirewallPolicyRuleMatchLayer4ConfigArray{
			&compute.NetworkFirewallPolicyRuleMatchLayer4ConfigArgs{
				IpProtocol: pulumi.String("string"),
				Ports: pulumi.StringArray{
					pulumi.String("string"),
				},
			},
		},
		DestAddressGroups: pulumi.StringArray{
			pulumi.String("string"),
		},
		DestFqdns: pulumi.StringArray{
			pulumi.String("string"),
		},
		DestIpRanges: pulumi.StringArray{
			pulumi.String("string"),
		},
		DestRegionCodes: pulumi.StringArray{
			pulumi.String("string"),
		},
		DestThreatIntelligences: pulumi.StringArray{
			pulumi.String("string"),
		},
		SrcAddressGroups: pulumi.StringArray{
			pulumi.String("string"),
		},
		SrcFqdns: pulumi.StringArray{
			pulumi.String("string"),
		},
		SrcIpRanges: pulumi.StringArray{
			pulumi.String("string"),
		},
		SrcRegionCodes: pulumi.StringArray{
			pulumi.String("string"),
		},
		SrcSecureTags: compute.NetworkFirewallPolicyRuleMatchSrcSecureTagArray{
			&compute.NetworkFirewallPolicyRuleMatchSrcSecureTagArgs{
				Name:  pulumi.String("string"),
				State: pulumi.String("string"),
			},
		},
		SrcThreatIntelligences: pulumi.StringArray{
			pulumi.String("string"),
		},
	},
	Disabled:             pulumi.Bool(false),
	EnableLogging:        pulumi.Bool(false),
	Description:          pulumi.String("string"),
	Project:              pulumi.String("string"),
	RuleName:             pulumi.String("string"),
	SecurityProfileGroup: pulumi.String("string"),
	TargetSecureTags: compute.NetworkFirewallPolicyRuleTargetSecureTagArray{
		&compute.NetworkFirewallPolicyRuleTargetSecureTagArgs{
			Name:  pulumi.String("string"),
			State: pulumi.String("string"),
		},
	},
	TargetServiceAccounts: pulumi.StringArray{
		pulumi.String("string"),
	},
	TlsInspect: pulumi.Bool(false),
})

var networkFirewallPolicyRuleResource = new NetworkFirewallPolicyRule("networkFirewallPolicyRuleResource", NetworkFirewallPolicyRuleArgs.builder()
    .firewallPolicy("string")
    .priority(0)
    .direction("string")
    .action("string")
    .match(NetworkFirewallPolicyRuleMatchArgs.builder()
        .layer4Configs(NetworkFirewallPolicyRuleMatchLayer4ConfigArgs.builder()
            .ipProtocol("string")
            .ports("string")
            .build())
        .destAddressGroups("string")
        .destFqdns("string")
        .destIpRanges("string")
        .destRegionCodes("string")
        .destThreatIntelligences("string")
        .srcAddressGroups("string")
        .srcFqdns("string")
        .srcIpRanges("string")
        .srcRegionCodes("string")
        .srcSecureTags(NetworkFirewallPolicyRuleMatchSrcSecureTagArgs.builder()
            .name("string")
            .state("string")
            .build())
        .srcThreatIntelligences("string")
        .build())
    .disabled(false)
    .enableLogging(false)
    .description("string")
    .project("string")
    .ruleName("string")
    .securityProfileGroup("string")
    .targetSecureTags(NetworkFirewallPolicyRuleTargetSecureTagArgs.builder()
        .name("string")
        .state("string")
        .build())
    .targetServiceAccounts("string")
    .tlsInspect(false)
    .build());

network_firewall_policy_rule_resource = gcp.compute.NetworkFirewallPolicyRule("networkFirewallPolicyRuleResource",
    firewall_policy="string",
    priority=0,
    direction="string",
    action="string",
    match={
        "layer4_configs": [{
            "ip_protocol": "string",
            "ports": ["string"],
        }],
        "dest_address_groups": ["string"],
        "dest_fqdns": ["string"],
        "dest_ip_ranges": ["string"],
        "dest_region_codes": ["string"],
        "dest_threat_intelligences": ["string"],
        "src_address_groups": ["string"],
        "src_fqdns": ["string"],
        "src_ip_ranges": ["string"],
        "src_region_codes": ["string"],
        "src_secure_tags": [{
            "name": "string",
            "state": "string",
        }],
        "src_threat_intelligences": ["string"],
    },
    disabled=False,
    enable_logging=False,
    description="string",
    project="string",
    rule_name="string",
    security_profile_group="string",
    target_secure_tags=[{
        "name": "string",
        "state": "string",
    }],
    target_service_accounts=["string"],
    tls_inspect=False)

const networkFirewallPolicyRuleResource = new gcp.compute.NetworkFirewallPolicyRule("networkFirewallPolicyRuleResource", {
    firewallPolicy: "string",
    priority: 0,
    direction: "string",
    action: "string",
    match: {
        layer4Configs: [{
            ipProtocol: "string",
            ports: ["string"],
        }],
        destAddressGroups: ["string"],
        destFqdns: ["string"],
        destIpRanges: ["string"],
        destRegionCodes: ["string"],
        destThreatIntelligences: ["string"],
        srcAddressGroups: ["string"],
        srcFqdns: ["string"],
        srcIpRanges: ["string"],
        srcRegionCodes: ["string"],
        srcSecureTags: [{
            name: "string",
            state: "string",
        }],
        srcThreatIntelligences: ["string"],
    },
    disabled: false,
    enableLogging: false,
    description: "string",
    project: "string",
    ruleName: "string",
    securityProfileGroup: "string",
    targetSecureTags: [{
        name: "string",
        state: "string",
    }],
    targetServiceAccounts: ["string"],
    tlsInspect: false,
});

type: gcp:compute:NetworkFirewallPolicyRule
properties:
    action: string
    description: string
    direction: string
    disabled: false
    enableLogging: false
    firewallPolicy: string
    match:
        destAddressGroups:
            - string
        destFqdns:
            - string
        destIpRanges:
            - string
        destRegionCodes:
            - string
        destThreatIntelligences:
            - string
        layer4Configs:
            - ipProtocol: string
              ports:
                - string
        srcAddressGroups:
            - string
        srcFqdns:
            - string
        srcIpRanges:
            - string
        srcRegionCodes:
            - string
        srcSecureTags:
            - name: string
              state: string
        srcThreatIntelligences:
            - string
    priority: 0
    project: string
    ruleName: string
    securityProfileGroup: string
    targetSecureTags:
        - name: string
          state: string
    targetServiceAccounts:
        - string
    tlsInspect: false