nsxt.PolicyBaremetalServerTags

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

// Discover bare metal servers
const productionServers = nsxt.getPolicyBaremetalServers({});
// Apply tags to a specific bare metal server
const webServerTags = new nsxt.PolicyBaremetalServerTags("web_server_tags", {
    externalId: productionServers.then(productionServers => productionServers.results?.[0]?.externalId),
    tags: [
        {
            scope: "environment",
            tag: "production",
        },
        {
            scope: "application",
            tag: "web-server",
        },
        {
            scope: "owner",
            tag: "platform-team",
        },
    ],
});
// Use tagged servers in a dynamic group
const productionWebServers = new nsxt.PolicyGroup("production_web_servers", {
    displayName: "Production-Web-Servers",
    description: "Dynamic group of production web servers",
    groupType: "BareMetalServer",
    criterias: [
        {
            conditions: [{
                key: "Tag",
                memberType: "BareMetalServer",
                operator: "EQUALS",
                value: "environment|production",
            }],
        },
        {
            conditions: [{
                key: "Tag",
                memberType: "BareMetalServer",
                operator: "EQUALS",
                value: "application|web-server",
            }],
        },
    ],
    conjunctions: [{
        operator: "AND",
    }],
});
// Define required services
const http = new nsxt.PolicyService("http", {
    displayName: "HTTP-Service",
    l4PortSetEntries: [{
        protocol: "TCP",
        destinationPorts: ["80"],
    }],
});
const https = new nsxt.PolicyService("https", {
    displayName: "HTTPS-Service",
    l4PortSetEntries: [{
        protocol: "TCP",
        destinationPorts: ["443"],
    }],
});
// Apply security policy to tagged servers
const webServerSecurity = new nsxt.PolicySecurityPolicy("web_server_security", {
    displayName: "Web-Server-Security",
    description: "Security policy for web servers",
    category: "Application",
    rules: [{
        displayName: "Allow-HTTP-HTTPS",
        sourceGroups: [],
        destinationGroups: [productionWebServers.path],
        action: "ALLOW",
        services: [
            http.path,
            https.path,
        ],
        logged: true,
    }],
});

import pulumi
import pulumi_nsxt as nsxt

# Discover bare metal servers
production_servers = nsxt.get_policy_baremetal_servers()
# Apply tags to a specific bare metal server
web_server_tags = nsxt.PolicyBaremetalServerTags("web_server_tags",
    external_id=production_servers.results[0].external_id,
    tags=[
        {
            "scope": "environment",
            "tag": "production",
        },
        {
            "scope": "application",
            "tag": "web-server",
        },
        {
            "scope": "owner",
            "tag": "platform-team",
        },
    ])
# Use tagged servers in a dynamic group
production_web_servers = nsxt.PolicyGroup("production_web_servers",
    display_name="Production-Web-Servers",
    description="Dynamic group of production web servers",
    group_type="BareMetalServer",
    criterias=[
        {
            "conditions": [{
                "key": "Tag",
                "member_type": "BareMetalServer",
                "operator": "EQUALS",
                "value": "environment|production",
            }],
        },
        {
            "conditions": [{
                "key": "Tag",
                "member_type": "BareMetalServer",
                "operator": "EQUALS",
                "value": "application|web-server",
            }],
        },
    ],
    conjunctions=[{
        "operator": "AND",
    }])
# Define required services
http = nsxt.PolicyService("http",
    display_name="HTTP-Service",
    l4_port_set_entries=[{
        "protocol": "TCP",
        "destination_ports": ["80"],
    }])
https = nsxt.PolicyService("https",
    display_name="HTTPS-Service",
    l4_port_set_entries=[{
        "protocol": "TCP",
        "destination_ports": ["443"],
    }])
# Apply security policy to tagged servers
web_server_security = nsxt.PolicySecurityPolicy("web_server_security",
    display_name="Web-Server-Security",
    description="Security policy for web servers",
    category="Application",
    rules=[{
        "display_name": "Allow-HTTP-HTTPS",
        "source_groups": [],
        "destination_groups": [production_web_servers.path],
        "action": "ALLOW",
        "services": [
            http.path,
            https.path,
        ],
        "logged": True,
    }])

package main

import (
	"github.com/pulumi/pulumi-terraform-provider/sdks/go/nsxt/v3/nsxt"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// Discover bare metal servers
		productionServers, err := nsxt.LookupPolicyBaremetalServers(ctx, &nsxt.LookupPolicyBaremetalServersArgs{}, nil)
		if err != nil {
			return err
		}
		// Apply tags to a specific bare metal server
		_, err = nsxt.NewPolicyBaremetalServerTags(ctx, "web_server_tags", &nsxt.PolicyBaremetalServerTagsArgs{
			ExternalId: pulumi.String(productionServers.Results[0].ExternalId),
			Tags: nsxt.PolicyBaremetalServerTagsTagArray{
				&nsxt.PolicyBaremetalServerTagsTagArgs{
					Scope: pulumi.String("environment"),
					Tag:   pulumi.String("production"),
				},
				&nsxt.PolicyBaremetalServerTagsTagArgs{
					Scope: pulumi.String("application"),
					Tag:   pulumi.String("web-server"),
				},
				&nsxt.PolicyBaremetalServerTagsTagArgs{
					Scope: pulumi.String("owner"),
					Tag:   pulumi.String("platform-team"),
				},
			},
		})
		if err != nil {
			return err
		}
		// Use tagged servers in a dynamic group
		productionWebServers, err := nsxt.NewPolicyGroup(ctx, "production_web_servers", &nsxt.PolicyGroupArgs{
			DisplayName: pulumi.String("Production-Web-Servers"),
			Description: pulumi.String("Dynamic group of production web servers"),
			GroupType:   pulumi.String("BareMetalServer"),
			Criterias: nsxt.PolicyGroupCriteriaArray{
				&nsxt.PolicyGroupCriteriaArgs{
					Conditions: nsxt.PolicyGroupCriteriaConditionArray{
						&nsxt.PolicyGroupCriteriaConditionArgs{
							Key:        pulumi.String("Tag"),
							MemberType: pulumi.String("BareMetalServer"),
							Operator:   pulumi.String("EQUALS"),
							Value:      pulumi.String("environment|production"),
						},
					},
				},
				&nsxt.PolicyGroupCriteriaArgs{
					Conditions: nsxt.PolicyGroupCriteriaConditionArray{
						&nsxt.PolicyGroupCriteriaConditionArgs{
							Key:        pulumi.String("Tag"),
							MemberType: pulumi.String("BareMetalServer"),
							Operator:   pulumi.String("EQUALS"),
							Value:      pulumi.String("application|web-server"),
						},
					},
				},
			},
			Conjunctions: nsxt.PolicyGroupConjunctionArray{
				&nsxt.PolicyGroupConjunctionArgs{
					Operator: pulumi.String("AND"),
				},
			},
		})
		if err != nil {
			return err
		}
		// Define required services
		http, err := nsxt.NewPolicyService(ctx, "http", &nsxt.PolicyServiceArgs{
			DisplayName: pulumi.String("HTTP-Service"),
			L4PortSetEntries: nsxt.PolicyServiceL4PortSetEntryArray{
				&nsxt.PolicyServiceL4PortSetEntryArgs{
					Protocol: pulumi.String("TCP"),
					DestinationPorts: pulumi.StringArray{
						pulumi.String("80"),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		https, err := nsxt.NewPolicyService(ctx, "https", &nsxt.PolicyServiceArgs{
			DisplayName: pulumi.String("HTTPS-Service"),
			L4PortSetEntries: nsxt.PolicyServiceL4PortSetEntryArray{
				&nsxt.PolicyServiceL4PortSetEntryArgs{
					Protocol: pulumi.String("TCP"),
					DestinationPorts: pulumi.StringArray{
						pulumi.String("443"),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		// Apply security policy to tagged servers
		_, err = nsxt.NewPolicySecurityPolicy(ctx, "web_server_security", &nsxt.PolicySecurityPolicyArgs{
			DisplayName: pulumi.String("Web-Server-Security"),
			Description: pulumi.String("Security policy for web servers"),
			Category:    pulumi.String("Application"),
			Rules: nsxt.PolicySecurityPolicyRuleTypeArray{
				&nsxt.PolicySecurityPolicyRuleTypeArgs{
					DisplayName:  pulumi.String("Allow-HTTP-HTTPS"),
					SourceGroups: pulumi.StringArray{},
					DestinationGroups: pulumi.StringArray{
						productionWebServers.Path,
					},
					Action: pulumi.String("ALLOW"),
					Services: pulumi.StringArray{
						http.Path,
						https.Path,
					},
					Logged: pulumi.Bool(true),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    // Discover bare metal servers
    var productionServers = Nsxt.GetPolicyBaremetalServers.Invoke();

    // Apply tags to a specific bare metal server
    var webServerTags = new Nsxt.PolicyBaremetalServerTags("web_server_tags", new()
    {
        ExternalId = productionServers.Apply(getPolicyBaremetalServersResult => getPolicyBaremetalServersResult.Results[0]?.ExternalId),
        Tags = new[]
        {
            new Nsxt.Inputs.PolicyBaremetalServerTagsTagArgs
            {
                Scope = "environment",
                Tag = "production",
            },
            new Nsxt.Inputs.PolicyBaremetalServerTagsTagArgs
            {
                Scope = "application",
                Tag = "web-server",
            },
            new Nsxt.Inputs.PolicyBaremetalServerTagsTagArgs
            {
                Scope = "owner",
                Tag = "platform-team",
            },
        },
    });

    // Use tagged servers in a dynamic group
    var productionWebServers = new Nsxt.PolicyGroup("production_web_servers", new()
    {
        DisplayName = "Production-Web-Servers",
        Description = "Dynamic group of production web servers",
        GroupType = "BareMetalServer",
        Criterias = new[]
        {
            new Nsxt.Inputs.PolicyGroupCriteriaArgs
            {
                Conditions = new[]
                {
                    new Nsxt.Inputs.PolicyGroupCriteriaConditionArgs
                    {
                        Key = "Tag",
                        MemberType = "BareMetalServer",
                        Operator = "EQUALS",
                        Value = "environment|production",
                    },
                },
            },
            new Nsxt.Inputs.PolicyGroupCriteriaArgs
            {
                Conditions = new[]
                {
                    new Nsxt.Inputs.PolicyGroupCriteriaConditionArgs
                    {
                        Key = "Tag",
                        MemberType = "BareMetalServer",
                        Operator = "EQUALS",
                        Value = "application|web-server",
                    },
                },
            },
        },
        Conjunctions = new[]
        {
            new Nsxt.Inputs.PolicyGroupConjunctionArgs
            {
                Operator = "AND",
            },
        },
    });

    // Define required services
    var http = new Nsxt.PolicyService("http", new()
    {
        DisplayName = "HTTP-Service",
        L4PortSetEntries = new[]
        {
            new Nsxt.Inputs.PolicyServiceL4PortSetEntryArgs
            {
                Protocol = "TCP",
                DestinationPorts = new[]
                {
                    "80",
                },
            },
        },
    });

    var https = new Nsxt.PolicyService("https", new()
    {
        DisplayName = "HTTPS-Service",
        L4PortSetEntries = new[]
        {
            new Nsxt.Inputs.PolicyServiceL4PortSetEntryArgs
            {
                Protocol = "TCP",
                DestinationPorts = new[]
                {
                    "443",
                },
            },
        },
    });

    // Apply security policy to tagged servers
    var webServerSecurity = new Nsxt.PolicySecurityPolicy("web_server_security", new()
    {
        DisplayName = "Web-Server-Security",
        Description = "Security policy for web servers",
        Category = "Application",
        Rules = new[]
        {
            new Nsxt.Inputs.PolicySecurityPolicyRuleArgs
            {
                DisplayName = "Allow-HTTP-HTTPS",
                SourceGroups = new() { },
                DestinationGroups = new[]
                {
                    productionWebServers.Path,
                },
                Action = "ALLOW",
                Services = new[]
                {
                    http.Path,
                    https.Path,
                },
                Logged = true,
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.nsxt.NsxtFunctions;
import com.pulumi.nsxt.inputs.GetPolicyBaremetalServersArgs;
import com.pulumi.nsxt.PolicyBaremetalServerTags;
import com.pulumi.nsxt.PolicyBaremetalServerTagsArgs;
import com.pulumi.nsxt.inputs.PolicyBaremetalServerTagsTagArgs;
import com.pulumi.nsxt.PolicyGroup;
import com.pulumi.nsxt.PolicyGroupArgs;
import com.pulumi.nsxt.inputs.PolicyGroupCriteriaArgs;
import com.pulumi.nsxt.inputs.PolicyGroupConjunctionArgs;
import com.pulumi.nsxt.PolicyService;
import com.pulumi.nsxt.PolicyServiceArgs;
import com.pulumi.nsxt.inputs.PolicyServiceL4PortSetEntryArgs;
import com.pulumi.nsxt.PolicySecurityPolicy;
import com.pulumi.nsxt.PolicySecurityPolicyArgs;
import com.pulumi.nsxt.inputs.PolicySecurityPolicyRuleArgs;
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) {
        // Discover bare metal servers
        final var productionServers = NsxtFunctions.getPolicyBaremetalServers(GetPolicyBaremetalServersArgs.builder()
            .build());

        // Apply tags to a specific bare metal server
        var webServerTags = new PolicyBaremetalServerTags("webServerTags", PolicyBaremetalServerTagsArgs.builder()
            .externalId(productionServers.results()[0].externalId())
            .tags(            
                PolicyBaremetalServerTagsTagArgs.builder()
                    .scope("environment")
                    .tag("production")
                    .build(),
                PolicyBaremetalServerTagsTagArgs.builder()
                    .scope("application")
                    .tag("web-server")
                    .build(),
                PolicyBaremetalServerTagsTagArgs.builder()
                    .scope("owner")
                    .tag("platform-team")
                    .build())
            .build());

        // Use tagged servers in a dynamic group
        var productionWebServers = new PolicyGroup("productionWebServers", PolicyGroupArgs.builder()
            .displayName("Production-Web-Servers")
            .description("Dynamic group of production web servers")
            .groupType("BareMetalServer")
            .criterias(            
                PolicyGroupCriteriaArgs.builder()
                    .conditions(PolicyGroupCriteriaConditionArgs.builder()
                        .key("Tag")
                        .memberType("BareMetalServer")
                        .operator("EQUALS")
                        .value("environment|production")
                        .build())
                    .build(),
                PolicyGroupCriteriaArgs.builder()
                    .conditions(PolicyGroupCriteriaConditionArgs.builder()
                        .key("Tag")
                        .memberType("BareMetalServer")
                        .operator("EQUALS")
                        .value("application|web-server")
                        .build())
                    .build())
            .conjunctions(PolicyGroupConjunctionArgs.builder()
                .operator("AND")
                .build())
            .build());

        // Define required services
        var http = new PolicyService("http", PolicyServiceArgs.builder()
            .displayName("HTTP-Service")
            .l4PortSetEntries(PolicyServiceL4PortSetEntryArgs.builder()
                .protocol("TCP")
                .destinationPorts("80")
                .build())
            .build());

        var https = new PolicyService("https", PolicyServiceArgs.builder()
            .displayName("HTTPS-Service")
            .l4PortSetEntries(PolicyServiceL4PortSetEntryArgs.builder()
                .protocol("TCP")
                .destinationPorts("443")
                .build())
            .build());

        // Apply security policy to tagged servers
        var webServerSecurity = new PolicySecurityPolicy("webServerSecurity", PolicySecurityPolicyArgs.builder()
            .displayName("Web-Server-Security")
            .description("Security policy for web servers")
            .category("Application")
            .rules(PolicySecurityPolicyRuleArgs.builder()
                .displayName("Allow-HTTP-HTTPS")
                .sourceGroups()
                .destinationGroups(productionWebServers.path())
                .action("ALLOW")
                .services(                
                    http.path(),
                    https.path())
                .logged(true)
                .build())
            .build());

    }
}

resources:
  # Apply tags to a specific bare metal server
  webServerTags:
    type: nsxt:PolicyBaremetalServerTags
    name: web_server_tags
    properties:
      externalId: ${productionServers.results[0].externalId}
      tags:
        - scope: environment
          tag: production
        - scope: application
          tag: web-server
        - scope: owner
          tag: platform-team
  # Use tagged servers in a dynamic group
  productionWebServers:
    type: nsxt:PolicyGroup
    name: production_web_servers
    properties:
      displayName: Production-Web-Servers
      description: Dynamic group of production web servers
      groupType: BareMetalServer
      criterias:
        - conditions:
            - key: Tag
              memberType: BareMetalServer
              operator: EQUALS
              value: environment|production
        - conditions:
            - key: Tag
              memberType: BareMetalServer
              operator: EQUALS
              value: application|web-server
      conjunctions:
        - operator: AND
  # Define required services
  http:
    type: nsxt:PolicyService
    properties:
      displayName: HTTP-Service
      l4PortSetEntries:
        - protocol: TCP
          destinationPorts:
            - '80'
  https:
    type: nsxt:PolicyService
    properties:
      displayName: HTTPS-Service
      l4PortSetEntries:
        - protocol: TCP
          destinationPorts:
            - '443'
  # Apply security policy to tagged servers
  webServerSecurity:
    type: nsxt:PolicySecurityPolicy
    name: web_server_security
    properties:
      displayName: Web-Server-Security
      description: Security policy for web servers
      category: Application
      rules:
        - displayName: Allow-HTTP-HTTPS
          sourceGroups: []
          destinationGroups:
            - ${productionWebServers.path}
          action: ALLOW
          services:
            - ${http.path}
            - ${https.path}
          logged: true
variables:
  # Discover bare metal servers
  productionServers:
    fn::invoke:
      function: nsxt:getPolicyBaremetalServers
      arguments: {}

var policyBaremetalServerTagsResource = new Nsxt.PolicyBaremetalServerTags("policyBaremetalServerTagsResource", new()
{
    ExternalId = "string",
    PolicyBaremetalServerTagsId = "string",
    Tags = new[]
    {
        new Nsxt.Inputs.PolicyBaremetalServerTagsTagArgs
        {
            Scope = "string",
            Tag = "string",
        },
    },
});

example, err := nsxt.NewPolicyBaremetalServerTags(ctx, "policyBaremetalServerTagsResource", &nsxt.PolicyBaremetalServerTagsArgs{
	ExternalId:                  pulumi.String("string"),
	PolicyBaremetalServerTagsId: pulumi.String("string"),
	Tags: nsxt.PolicyBaremetalServerTagsTagArray{
		&nsxt.PolicyBaremetalServerTagsTagArgs{
			Scope: pulumi.String("string"),
			Tag:   pulumi.String("string"),
		},
	},
})

resource "nsxt_policy_baremetal_server_tags" "policyBaremetalServerTagsResource" {
  lifecycle {
    create_before_destroy = true
  }
  external_id                     = "string"
  policy_baremetal_server_tags_id = "string"
  tags {
    scope = "string"
    tag   = "string"
  }
}

var policyBaremetalServerTagsResource = new PolicyBaremetalServerTags("policyBaremetalServerTagsResource", PolicyBaremetalServerTagsArgs.builder()
    .externalId("string")
    .policyBaremetalServerTagsId("string")
    .tags(PolicyBaremetalServerTagsTagArgs.builder()
        .scope("string")
        .tag("string")
        .build())
    .build());

policy_baremetal_server_tags_resource = nsxt.PolicyBaremetalServerTags("policyBaremetalServerTagsResource",
    external_id="string",
    policy_baremetal_server_tags_id="string",
    tags=[{
        "scope": "string",
        "tag": "string",
    }])

const policyBaremetalServerTagsResource = new nsxt.PolicyBaremetalServerTags("policyBaremetalServerTagsResource", {
    externalId: "string",
    policyBaremetalServerTagsId: "string",
    tags: [{
        scope: "string",
        tag: "string",
    }],
});

type: nsxt:PolicyBaremetalServerTags
properties:
    externalId: string
    policyBaremetalServerTagsId: string
    tags:
        - scope: string
          tag: string