harness.chaos.SecurityGovernanceCondition

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

// Example of a Kubernetes Security Governance Condition
const k8sCondition = new harness.chaos.SecurityGovernanceCondition("k8s_condition", {
    orgId: orgId,
    projectId: projectId,
    name: "k8s-security-condition",
    description: "Security governance condition for Kubernetes workloads",
    infraType: "KubernetesV2",
    faultSpec: {
        operator: "NOT_EQUAL_TO",
        faults: [
            {
                faultType: "FAULT",
                name: "pod-delete",
            },
            {
                faultType: "FAULT",
                name: "pod-dns",
            },
        ],
    },
    k8sSpec: {
        infraSpec: {
            operator: "EQUAL_TO",
            infraIds: [k8sInfraId],
        },
        applicationSpec: {
            operator: "EQUAL_TO",
            workloads: [{
                namespace: "default",
                kind: "deployment",
                label: "app=nginx",
                services: ["nginx-service"],
                applicationMapId: "nginx-app",
            }],
        },
        chaosServiceAccountSpec: {
            operator: "EQUAL_TO",
            serviceAccounts: [
                "default",
                "chaos-service-account",
            ],
        },
    },
    tags: [
        "env:prod",
        "team:security",
        "platform:k8s",
    ],
});
// Example of a Windows Security Governance Condition
const windowsCondition = new harness.chaos.SecurityGovernanceCondition("windows_condition", {
    orgId: orgId,
    projectId: projectId,
    name: "windows-security-condition",
    description: "Security governance condition for Windows hosts",
    infraType: "Windows",
    faultSpec: {
        operator: "NOT_EQUAL_TO",
        faults: [
            {
                faultType: "FAULT",
                name: "process-kill",
            },
            {
                faultType: "FAULT",
                name: "cpu-hog",
            },
        ],
    },
    machineSpec: {
        infraSpec: {
            operator: "EQUAL_TO",
            infraIds: [windowsInfraId],
        },
    },
    tags: [
        "env:prod",
        "team:security",
        "platform:windows",
    ],
});
// Example of a Linux Security Governance Condition
const linuxCondition = new harness.chaos.SecurityGovernanceCondition("linux_condition", {
    orgId: orgId,
    projectId: projectId,
    name: "linux-security-condition",
    description: "Security governance condition for Linux hosts",
    infraType: "Linux",
    faultSpec: {
        operator: "NOT_EQUAL_TO",
        faults: [
            {
                faultType: "FAULT",
                name: "process-kill",
            },
            {
                faultType: "FAULT",
                name: "memory-hog",
            },
        ],
    },
    machineSpec: {
        infraSpec: {
            operator: "EQUAL_TO",
            infraIds: [linuxInfraId],
        },
    },
    tags: [
        "env:prod",
        "team:security",
        "platform:linux",
    ],
});
export const k8sConditionId = k8sCondition.id;
export const windowsConditionId = windowsCondition.id;
export const linuxConditionId = linuxCondition.id;

import pulumi
import pulumi_harness as harness

# Example of a Kubernetes Security Governance Condition
k8s_condition = harness.chaos.SecurityGovernanceCondition("k8s_condition",
    org_id=org_id,
    project_id=project_id,
    name="k8s-security-condition",
    description="Security governance condition for Kubernetes workloads",
    infra_type="KubernetesV2",
    fault_spec={
        "operator": "NOT_EQUAL_TO",
        "faults": [
            {
                "fault_type": "FAULT",
                "name": "pod-delete",
            },
            {
                "fault_type": "FAULT",
                "name": "pod-dns",
            },
        ],
    },
    k8s_spec={
        "infra_spec": {
            "operator": "EQUAL_TO",
            "infra_ids": [k8s_infra_id],
        },
        "application_spec": {
            "operator": "EQUAL_TO",
            "workloads": [{
                "namespace": "default",
                "kind": "deployment",
                "label": "app=nginx",
                "services": ["nginx-service"],
                "application_map_id": "nginx-app",
            }],
        },
        "chaos_service_account_spec": {
            "operator": "EQUAL_TO",
            "service_accounts": [
                "default",
                "chaos-service-account",
            ],
        },
    },
    tags=[
        "env:prod",
        "team:security",
        "platform:k8s",
    ])
# Example of a Windows Security Governance Condition
windows_condition = harness.chaos.SecurityGovernanceCondition("windows_condition",
    org_id=org_id,
    project_id=project_id,
    name="windows-security-condition",
    description="Security governance condition for Windows hosts",
    infra_type="Windows",
    fault_spec={
        "operator": "NOT_EQUAL_TO",
        "faults": [
            {
                "fault_type": "FAULT",
                "name": "process-kill",
            },
            {
                "fault_type": "FAULT",
                "name": "cpu-hog",
            },
        ],
    },
    machine_spec={
        "infra_spec": {
            "operator": "EQUAL_TO",
            "infra_ids": [windows_infra_id],
        },
    },
    tags=[
        "env:prod",
        "team:security",
        "platform:windows",
    ])
# Example of a Linux Security Governance Condition
linux_condition = harness.chaos.SecurityGovernanceCondition("linux_condition",
    org_id=org_id,
    project_id=project_id,
    name="linux-security-condition",
    description="Security governance condition for Linux hosts",
    infra_type="Linux",
    fault_spec={
        "operator": "NOT_EQUAL_TO",
        "faults": [
            {
                "fault_type": "FAULT",
                "name": "process-kill",
            },
            {
                "fault_type": "FAULT",
                "name": "memory-hog",
            },
        ],
    },
    machine_spec={
        "infra_spec": {
            "operator": "EQUAL_TO",
            "infra_ids": [linux_infra_id],
        },
    },
    tags=[
        "env:prod",
        "team:security",
        "platform:linux",
    ])
pulumi.export("k8sConditionId", k8s_condition.id)
pulumi.export("windowsConditionId", windows_condition.id)
pulumi.export("linuxConditionId", linux_condition.id)

package main

import (
	"github.com/pulumi/pulumi-harness/sdk/go/harness/chaos"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// Example of a Kubernetes Security Governance Condition
		k8sCondition, err := chaos.NewSecurityGovernanceCondition(ctx, "k8s_condition", &chaos.SecurityGovernanceConditionArgs{
			OrgId:       pulumi.Any(orgId),
			ProjectId:   pulumi.Any(projectId),
			Name:        pulumi.String("k8s-security-condition"),
			Description: pulumi.String("Security governance condition for Kubernetes workloads"),
			InfraType:   pulumi.String("KubernetesV2"),
			FaultSpec: &chaos.SecurityGovernanceConditionFaultSpecArgs{
				Operator: pulumi.String("NOT_EQUAL_TO"),
				Faults: chaos.SecurityGovernanceConditionFaultSpecFaultArray{
					&chaos.SecurityGovernanceConditionFaultSpecFaultArgs{
						FaultType: pulumi.String("FAULT"),
						Name:      pulumi.String("pod-delete"),
					},
					&chaos.SecurityGovernanceConditionFaultSpecFaultArgs{
						FaultType: pulumi.String("FAULT"),
						Name:      pulumi.String("pod-dns"),
					},
				},
			},
			K8sSpec: &chaos.SecurityGovernanceConditionK8sSpecArgs{
				InfraSpec: &chaos.SecurityGovernanceConditionK8sSpecInfraSpecArgs{
					Operator: pulumi.String("EQUAL_TO"),
					InfraIds: pulumi.StringArray{
						k8sInfraId,
					},
				},
				ApplicationSpec: &chaos.SecurityGovernanceConditionK8sSpecApplicationSpecArgs{
					Operator: pulumi.String("EQUAL_TO"),
					Workloads: chaos.SecurityGovernanceConditionK8sSpecApplicationSpecWorkloadArray{
						&chaos.SecurityGovernanceConditionK8sSpecApplicationSpecWorkloadArgs{
							Namespace: pulumi.String("default"),
							Kind:      pulumi.String("deployment"),
							Label:     pulumi.String("app=nginx"),
							Services: pulumi.StringArray{
								pulumi.String("nginx-service"),
							},
							ApplicationMapId: pulumi.String("nginx-app"),
						},
					},
				},
				ChaosServiceAccountSpec: &chaos.SecurityGovernanceConditionK8sSpecChaosServiceAccountSpecArgs{
					Operator: pulumi.String("EQUAL_TO"),
					ServiceAccounts: pulumi.StringArray{
						pulumi.String("default"),
						pulumi.String("chaos-service-account"),
					},
				},
			},
			Tags: pulumi.StringArray{
				pulumi.String("env:prod"),
				pulumi.String("team:security"),
				pulumi.String("platform:k8s"),
			},
		})
		if err != nil {
			return err
		}
		// Example of a Windows Security Governance Condition
		windowsCondition, err := chaos.NewSecurityGovernanceCondition(ctx, "windows_condition", &chaos.SecurityGovernanceConditionArgs{
			OrgId:       pulumi.Any(orgId),
			ProjectId:   pulumi.Any(projectId),
			Name:        pulumi.String("windows-security-condition"),
			Description: pulumi.String("Security governance condition for Windows hosts"),
			InfraType:   pulumi.String("Windows"),
			FaultSpec: &chaos.SecurityGovernanceConditionFaultSpecArgs{
				Operator: pulumi.String("NOT_EQUAL_TO"),
				Faults: chaos.SecurityGovernanceConditionFaultSpecFaultArray{
					&chaos.SecurityGovernanceConditionFaultSpecFaultArgs{
						FaultType: pulumi.String("FAULT"),
						Name:      pulumi.String("process-kill"),
					},
					&chaos.SecurityGovernanceConditionFaultSpecFaultArgs{
						FaultType: pulumi.String("FAULT"),
						Name:      pulumi.String("cpu-hog"),
					},
				},
			},
			MachineSpec: &chaos.SecurityGovernanceConditionMachineSpecArgs{
				InfraSpec: &chaos.SecurityGovernanceConditionMachineSpecInfraSpecArgs{
					Operator: pulumi.String("EQUAL_TO"),
					InfraIds: pulumi.StringArray{
						windowsInfraId,
					},
				},
			},
			Tags: pulumi.StringArray{
				pulumi.String("env:prod"),
				pulumi.String("team:security"),
				pulumi.String("platform:windows"),
			},
		})
		if err != nil {
			return err
		}
		// Example of a Linux Security Governance Condition
		linuxCondition, err := chaos.NewSecurityGovernanceCondition(ctx, "linux_condition", &chaos.SecurityGovernanceConditionArgs{
			OrgId:       pulumi.Any(orgId),
			ProjectId:   pulumi.Any(projectId),
			Name:        pulumi.String("linux-security-condition"),
			Description: pulumi.String("Security governance condition for Linux hosts"),
			InfraType:   pulumi.String("Linux"),
			FaultSpec: &chaos.SecurityGovernanceConditionFaultSpecArgs{
				Operator: pulumi.String("NOT_EQUAL_TO"),
				Faults: chaos.SecurityGovernanceConditionFaultSpecFaultArray{
					&chaos.SecurityGovernanceConditionFaultSpecFaultArgs{
						FaultType: pulumi.String("FAULT"),
						Name:      pulumi.String("process-kill"),
					},
					&chaos.SecurityGovernanceConditionFaultSpecFaultArgs{
						FaultType: pulumi.String("FAULT"),
						Name:      pulumi.String("memory-hog"),
					},
				},
			},
			MachineSpec: &chaos.SecurityGovernanceConditionMachineSpecArgs{
				InfraSpec: &chaos.SecurityGovernanceConditionMachineSpecInfraSpecArgs{
					Operator: pulumi.String("EQUAL_TO"),
					InfraIds: pulumi.StringArray{
						linuxInfraId,
					},
				},
			},
			Tags: pulumi.StringArray{
				pulumi.String("env:prod"),
				pulumi.String("team:security"),
				pulumi.String("platform:linux"),
			},
		})
		if err != nil {
			return err
		}
		ctx.Export("k8sConditionId", k8sCondition.ID())
		ctx.Export("windowsConditionId", windowsCondition.ID())
		ctx.Export("linuxConditionId", linuxCondition.ID())
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    // Example of a Kubernetes Security Governance Condition
    var k8sCondition = new Harness.Chaos.SecurityGovernanceCondition("k8s_condition", new()
    {
        OrgId = orgId,
        ProjectId = projectId,
        Name = "k8s-security-condition",
        Description = "Security governance condition for Kubernetes workloads",
        InfraType = "KubernetesV2",
        FaultSpec = new Harness.Chaos.Inputs.SecurityGovernanceConditionFaultSpecArgs
        {
            Operator = "NOT_EQUAL_TO",
            Faults = new[]
            {
                new Harness.Chaos.Inputs.SecurityGovernanceConditionFaultSpecFaultArgs
                {
                    FaultType = "FAULT",
                    Name = "pod-delete",
                },
                new Harness.Chaos.Inputs.SecurityGovernanceConditionFaultSpecFaultArgs
                {
                    FaultType = "FAULT",
                    Name = "pod-dns",
                },
            },
        },
        K8sSpec = new Harness.Chaos.Inputs.SecurityGovernanceConditionK8sSpecArgs
        {
            InfraSpec = new Harness.Chaos.Inputs.SecurityGovernanceConditionK8sSpecInfraSpecArgs
            {
                Operator = "EQUAL_TO",
                InfraIds = new[]
                {
                    k8sInfraId,
                },
            },
            ApplicationSpec = new Harness.Chaos.Inputs.SecurityGovernanceConditionK8sSpecApplicationSpecArgs
            {
                Operator = "EQUAL_TO",
                Workloads = new[]
                {
                    new Harness.Chaos.Inputs.SecurityGovernanceConditionK8sSpecApplicationSpecWorkloadArgs
                    {
                        Namespace = "default",
                        Kind = "deployment",
                        Label = "app=nginx",
                        Services = new[]
                        {
                            "nginx-service",
                        },
                        ApplicationMapId = "nginx-app",
                    },
                },
            },
            ChaosServiceAccountSpec = new Harness.Chaos.Inputs.SecurityGovernanceConditionK8sSpecChaosServiceAccountSpecArgs
            {
                Operator = "EQUAL_TO",
                ServiceAccounts = new[]
                {
                    "default",
                    "chaos-service-account",
                },
            },
        },
        Tags = new[]
        {
            "env:prod",
            "team:security",
            "platform:k8s",
        },
    });

    // Example of a Windows Security Governance Condition
    var windowsCondition = new Harness.Chaos.SecurityGovernanceCondition("windows_condition", new()
    {
        OrgId = orgId,
        ProjectId = projectId,
        Name = "windows-security-condition",
        Description = "Security governance condition for Windows hosts",
        InfraType = "Windows",
        FaultSpec = new Harness.Chaos.Inputs.SecurityGovernanceConditionFaultSpecArgs
        {
            Operator = "NOT_EQUAL_TO",
            Faults = new[]
            {
                new Harness.Chaos.Inputs.SecurityGovernanceConditionFaultSpecFaultArgs
                {
                    FaultType = "FAULT",
                    Name = "process-kill",
                },
                new Harness.Chaos.Inputs.SecurityGovernanceConditionFaultSpecFaultArgs
                {
                    FaultType = "FAULT",
                    Name = "cpu-hog",
                },
            },
        },
        MachineSpec = new Harness.Chaos.Inputs.SecurityGovernanceConditionMachineSpecArgs
        {
            InfraSpec = new Harness.Chaos.Inputs.SecurityGovernanceConditionMachineSpecInfraSpecArgs
            {
                Operator = "EQUAL_TO",
                InfraIds = new[]
                {
                    windowsInfraId,
                },
            },
        },
        Tags = new[]
        {
            "env:prod",
            "team:security",
            "platform:windows",
        },
    });

    // Example of a Linux Security Governance Condition
    var linuxCondition = new Harness.Chaos.SecurityGovernanceCondition("linux_condition", new()
    {
        OrgId = orgId,
        ProjectId = projectId,
        Name = "linux-security-condition",
        Description = "Security governance condition for Linux hosts",
        InfraType = "Linux",
        FaultSpec = new Harness.Chaos.Inputs.SecurityGovernanceConditionFaultSpecArgs
        {
            Operator = "NOT_EQUAL_TO",
            Faults = new[]
            {
                new Harness.Chaos.Inputs.SecurityGovernanceConditionFaultSpecFaultArgs
                {
                    FaultType = "FAULT",
                    Name = "process-kill",
                },
                new Harness.Chaos.Inputs.SecurityGovernanceConditionFaultSpecFaultArgs
                {
                    FaultType = "FAULT",
                    Name = "memory-hog",
                },
            },
        },
        MachineSpec = new Harness.Chaos.Inputs.SecurityGovernanceConditionMachineSpecArgs
        {
            InfraSpec = new Harness.Chaos.Inputs.SecurityGovernanceConditionMachineSpecInfraSpecArgs
            {
                Operator = "EQUAL_TO",
                InfraIds = new[]
                {
                    linuxInfraId,
                },
            },
        },
        Tags = new[]
        {
            "env:prod",
            "team:security",
            "platform:linux",
        },
    });

    return new Dictionary<string, object?>
    {
        ["k8sConditionId"] = k8sCondition.Id,
        ["windowsConditionId"] = windowsCondition.Id,
        ["linuxConditionId"] = linuxCondition.Id,
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.harness.chaos.SecurityGovernanceCondition;
import com.pulumi.harness.chaos.SecurityGovernanceConditionArgs;
import com.pulumi.harness.chaos.inputs.SecurityGovernanceConditionFaultSpecArgs;
import com.pulumi.harness.chaos.inputs.SecurityGovernanceConditionK8sSpecArgs;
import com.pulumi.harness.chaos.inputs.SecurityGovernanceConditionK8sSpecInfraSpecArgs;
import com.pulumi.harness.chaos.inputs.SecurityGovernanceConditionK8sSpecApplicationSpecArgs;
import com.pulumi.harness.chaos.inputs.SecurityGovernanceConditionK8sSpecChaosServiceAccountSpecArgs;
import com.pulumi.harness.chaos.inputs.SecurityGovernanceConditionMachineSpecArgs;
import com.pulumi.harness.chaos.inputs.SecurityGovernanceConditionMachineSpecInfraSpecArgs;
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) {
        // Example of a Kubernetes Security Governance Condition
        var k8sCondition = new SecurityGovernanceCondition("k8sCondition", SecurityGovernanceConditionArgs.builder()
            .orgId(orgId)
            .projectId(projectId)
            .name("k8s-security-condition")
            .description("Security governance condition for Kubernetes workloads")
            .infraType("KubernetesV2")
            .faultSpec(SecurityGovernanceConditionFaultSpecArgs.builder()
                .operator("NOT_EQUAL_TO")
                .faults(                
                    SecurityGovernanceConditionFaultSpecFaultArgs.builder()
                        .faultType("FAULT")
                        .name("pod-delete")
                        .build(),
                    SecurityGovernanceConditionFaultSpecFaultArgs.builder()
                        .faultType("FAULT")
                        .name("pod-dns")
                        .build())
                .build())
            .k8sSpec(SecurityGovernanceConditionK8sSpecArgs.builder()
                .infraSpec(SecurityGovernanceConditionK8sSpecInfraSpecArgs.builder()
                    .operator("EQUAL_TO")
                    .infraIds(k8sInfraId)
                    .build())
                .applicationSpec(SecurityGovernanceConditionK8sSpecApplicationSpecArgs.builder()
                    .operator("EQUAL_TO")
                    .workloads(SecurityGovernanceConditionK8sSpecApplicationSpecWorkloadArgs.builder()
                        .namespace("default")
                        .kind("deployment")
                        .label("app=nginx")
                        .services("nginx-service")
                        .applicationMapId("nginx-app")
                        .build())
                    .build())
                .chaosServiceAccountSpec(SecurityGovernanceConditionK8sSpecChaosServiceAccountSpecArgs.builder()
                    .operator("EQUAL_TO")
                    .serviceAccounts(                    
                        "default",
                        "chaos-service-account")
                    .build())
                .build())
            .tags(            
                "env:prod",
                "team:security",
                "platform:k8s")
            .build());

        // Example of a Windows Security Governance Condition
        var windowsCondition = new SecurityGovernanceCondition("windowsCondition", SecurityGovernanceConditionArgs.builder()
            .orgId(orgId)
            .projectId(projectId)
            .name("windows-security-condition")
            .description("Security governance condition for Windows hosts")
            .infraType("Windows")
            .faultSpec(SecurityGovernanceConditionFaultSpecArgs.builder()
                .operator("NOT_EQUAL_TO")
                .faults(                
                    SecurityGovernanceConditionFaultSpecFaultArgs.builder()
                        .faultType("FAULT")
                        .name("process-kill")
                        .build(),
                    SecurityGovernanceConditionFaultSpecFaultArgs.builder()
                        .faultType("FAULT")
                        .name("cpu-hog")
                        .build())
                .build())
            .machineSpec(SecurityGovernanceConditionMachineSpecArgs.builder()
                .infraSpec(SecurityGovernanceConditionMachineSpecInfraSpecArgs.builder()
                    .operator("EQUAL_TO")
                    .infraIds(windowsInfraId)
                    .build())
                .build())
            .tags(            
                "env:prod",
                "team:security",
                "platform:windows")
            .build());

        // Example of a Linux Security Governance Condition
        var linuxCondition = new SecurityGovernanceCondition("linuxCondition", SecurityGovernanceConditionArgs.builder()
            .orgId(orgId)
            .projectId(projectId)
            .name("linux-security-condition")
            .description("Security governance condition for Linux hosts")
            .infraType("Linux")
            .faultSpec(SecurityGovernanceConditionFaultSpecArgs.builder()
                .operator("NOT_EQUAL_TO")
                .faults(                
                    SecurityGovernanceConditionFaultSpecFaultArgs.builder()
                        .faultType("FAULT")
                        .name("process-kill")
                        .build(),
                    SecurityGovernanceConditionFaultSpecFaultArgs.builder()
                        .faultType("FAULT")
                        .name("memory-hog")
                        .build())
                .build())
            .machineSpec(SecurityGovernanceConditionMachineSpecArgs.builder()
                .infraSpec(SecurityGovernanceConditionMachineSpecInfraSpecArgs.builder()
                    .operator("EQUAL_TO")
                    .infraIds(linuxInfraId)
                    .build())
                .build())
            .tags(            
                "env:prod",
                "team:security",
                "platform:linux")
            .build());

        ctx.export("k8sConditionId", k8sCondition.id());
        ctx.export("windowsConditionId", windowsCondition.id());
        ctx.export("linuxConditionId", linuxCondition.id());
    }
}

resources:
  # Example of a Kubernetes Security Governance Condition
  k8sCondition:
    type: harness:chaos:SecurityGovernanceCondition
    name: k8s_condition
    properties:
      orgId: ${orgId}
      projectId: ${projectId}
      name: k8s-security-condition
      description: Security governance condition for Kubernetes workloads
      infraType: KubernetesV2
      faultSpec:
        operator: NOT_EQUAL_TO
        faults:
          - faultType: FAULT
            name: pod-delete
          - faultType: FAULT
            name: pod-dns
      k8sSpec:
        infraSpec:
          operator: EQUAL_TO
          infraIds:
            - ${k8sInfraId}
        applicationSpec:
          operator: EQUAL_TO
          workloads:
            - namespace: default
              kind: deployment
              label: app=nginx
              services:
                - nginx-service
              applicationMapId: nginx-app
        chaosServiceAccountSpec:
          operator: EQUAL_TO
          serviceAccounts:
            - default
            - chaos-service-account
      tags:
        - env:prod
        - team:security
        - platform:k8s
  # Example of a Windows Security Governance Condition
  windowsCondition:
    type: harness:chaos:SecurityGovernanceCondition
    name: windows_condition
    properties:
      orgId: ${orgId}
      projectId: ${projectId}
      name: windows-security-condition
      description: Security governance condition for Windows hosts
      infraType: Windows
      faultSpec:
        operator: NOT_EQUAL_TO
        faults:
          - faultType: FAULT
            name: process-kill
          - faultType: FAULT
            name: cpu-hog
      machineSpec:
        infraSpec:
          operator: EQUAL_TO
          infraIds:
            - ${windowsInfraId}
      tags:
        - env:prod
        - team:security
        - platform:windows
  # Example of a Linux Security Governance Condition
  linuxCondition:
    type: harness:chaos:SecurityGovernanceCondition
    name: linux_condition
    properties:
      orgId: ${orgId}
      projectId: ${projectId}
      name: linux-security-condition
      description: Security governance condition for Linux hosts
      infraType: Linux
      faultSpec:
        operator: NOT_EQUAL_TO
        faults:
          - faultType: FAULT
            name: process-kill
          - faultType: FAULT
            name: memory-hog
      machineSpec:
        infraSpec:
          operator: EQUAL_TO
          infraIds:
            - ${linuxInfraId}
      tags:
        - env:prod
        - team:security
        - platform:linux
outputs:
  # Output the created conditions
  k8sConditionId: ${k8sCondition.id}
  windowsConditionId: ${windowsCondition.id}
  linuxConditionId: ${linuxCondition.id}

var securityGovernanceConditionResource = new Harness.Chaos.SecurityGovernanceCondition("securityGovernanceConditionResource", new()
{
    FaultSpec = new Harness.Chaos.Inputs.SecurityGovernanceConditionFaultSpecArgs
    {
        Faults = new[]
        {
            new Harness.Chaos.Inputs.SecurityGovernanceConditionFaultSpecFaultArgs
            {
                FaultType = "string",
                Name = "string",
            },
        },
        Operator = "string",
    },
    InfraType = "string",
    OrgId = "string",
    ProjectId = "string",
    Description = "string",
    K8sSpec = new Harness.Chaos.Inputs.SecurityGovernanceConditionK8sSpecArgs
    {
        ApplicationSpec = new Harness.Chaos.Inputs.SecurityGovernanceConditionK8sSpecApplicationSpecArgs
        {
            Operator = "string",
            Workloads = new[]
            {
                new Harness.Chaos.Inputs.SecurityGovernanceConditionK8sSpecApplicationSpecWorkloadArgs
                {
                    Namespace = "string",
                    ApplicationMapId = "string",
                    Kind = "string",
                    Label = "string",
                    Services = new[]
                    {
                        "string",
                    },
                },
            },
        },
        ChaosServiceAccountSpec = new Harness.Chaos.Inputs.SecurityGovernanceConditionK8sSpecChaosServiceAccountSpecArgs
        {
            Operator = "string",
            ServiceAccounts = new[]
            {
                "string",
            },
        },
        InfraSpec = new Harness.Chaos.Inputs.SecurityGovernanceConditionK8sSpecInfraSpecArgs
        {
            InfraIds = new[]
            {
                "string",
            },
            Operator = "string",
        },
    },
    MachineSpec = new Harness.Chaos.Inputs.SecurityGovernanceConditionMachineSpecArgs
    {
        InfraSpec = new Harness.Chaos.Inputs.SecurityGovernanceConditionMachineSpecInfraSpecArgs
        {
            InfraIds = new[]
            {
                "string",
            },
            Operator = "string",
        },
    },
    Name = "string",
    Tags = new[]
    {
        "string",
    },
});

example, err := chaos.NewSecurityGovernanceCondition(ctx, "securityGovernanceConditionResource", &chaos.SecurityGovernanceConditionArgs{
	FaultSpec: &chaos.SecurityGovernanceConditionFaultSpecArgs{
		Faults: chaos.SecurityGovernanceConditionFaultSpecFaultArray{
			&chaos.SecurityGovernanceConditionFaultSpecFaultArgs{
				FaultType: pulumi.String("string"),
				Name:      pulumi.String("string"),
			},
		},
		Operator: pulumi.String("string"),
	},
	InfraType:   pulumi.String("string"),
	OrgId:       pulumi.String("string"),
	ProjectId:   pulumi.String("string"),
	Description: pulumi.String("string"),
	K8sSpec: &chaos.SecurityGovernanceConditionK8sSpecArgs{
		ApplicationSpec: &chaos.SecurityGovernanceConditionK8sSpecApplicationSpecArgs{
			Operator: pulumi.String("string"),
			Workloads: chaos.SecurityGovernanceConditionK8sSpecApplicationSpecWorkloadArray{
				&chaos.SecurityGovernanceConditionK8sSpecApplicationSpecWorkloadArgs{
					Namespace:        pulumi.String("string"),
					ApplicationMapId: pulumi.String("string"),
					Kind:             pulumi.String("string"),
					Label:            pulumi.String("string"),
					Services: pulumi.StringArray{
						pulumi.String("string"),
					},
				},
			},
		},
		ChaosServiceAccountSpec: &chaos.SecurityGovernanceConditionK8sSpecChaosServiceAccountSpecArgs{
			Operator: pulumi.String("string"),
			ServiceAccounts: pulumi.StringArray{
				pulumi.String("string"),
			},
		},
		InfraSpec: &chaos.SecurityGovernanceConditionK8sSpecInfraSpecArgs{
			InfraIds: pulumi.StringArray{
				pulumi.String("string"),
			},
			Operator: pulumi.String("string"),
		},
	},
	MachineSpec: &chaos.SecurityGovernanceConditionMachineSpecArgs{
		InfraSpec: &chaos.SecurityGovernanceConditionMachineSpecInfraSpecArgs{
			InfraIds: pulumi.StringArray{
				pulumi.String("string"),
			},
			Operator: pulumi.String("string"),
		},
	},
	Name: pulumi.String("string"),
	Tags: pulumi.StringArray{
		pulumi.String("string"),
	},
})

var securityGovernanceConditionResource = new SecurityGovernanceCondition("securityGovernanceConditionResource", SecurityGovernanceConditionArgs.builder()
    .faultSpec(SecurityGovernanceConditionFaultSpecArgs.builder()
        .faults(SecurityGovernanceConditionFaultSpecFaultArgs.builder()
            .faultType("string")
            .name("string")
            .build())
        .operator("string")
        .build())
    .infraType("string")
    .orgId("string")
    .projectId("string")
    .description("string")
    .k8sSpec(SecurityGovernanceConditionK8sSpecArgs.builder()
        .applicationSpec(SecurityGovernanceConditionK8sSpecApplicationSpecArgs.builder()
            .operator("string")
            .workloads(SecurityGovernanceConditionK8sSpecApplicationSpecWorkloadArgs.builder()
                .namespace("string")
                .applicationMapId("string")
                .kind("string")
                .label("string")
                .services("string")
                .build())
            .build())
        .chaosServiceAccountSpec(SecurityGovernanceConditionK8sSpecChaosServiceAccountSpecArgs.builder()
            .operator("string")
            .serviceAccounts("string")
            .build())
        .infraSpec(SecurityGovernanceConditionK8sSpecInfraSpecArgs.builder()
            .infraIds("string")
            .operator("string")
            .build())
        .build())
    .machineSpec(SecurityGovernanceConditionMachineSpecArgs.builder()
        .infraSpec(SecurityGovernanceConditionMachineSpecInfraSpecArgs.builder()
            .infraIds("string")
            .operator("string")
            .build())
        .build())
    .name("string")
    .tags("string")
    .build());

security_governance_condition_resource = harness.chaos.SecurityGovernanceCondition("securityGovernanceConditionResource",
    fault_spec={
        "faults": [{
            "fault_type": "string",
            "name": "string",
        }],
        "operator": "string",
    },
    infra_type="string",
    org_id="string",
    project_id="string",
    description="string",
    k8s_spec={
        "application_spec": {
            "operator": "string",
            "workloads": [{
                "namespace": "string",
                "application_map_id": "string",
                "kind": "string",
                "label": "string",
                "services": ["string"],
            }],
        },
        "chaos_service_account_spec": {
            "operator": "string",
            "service_accounts": ["string"],
        },
        "infra_spec": {
            "infra_ids": ["string"],
            "operator": "string",
        },
    },
    machine_spec={
        "infra_spec": {
            "infra_ids": ["string"],
            "operator": "string",
        },
    },
    name="string",
    tags=["string"])

const securityGovernanceConditionResource = new harness.chaos.SecurityGovernanceCondition("securityGovernanceConditionResource", {
    faultSpec: {
        faults: [{
            faultType: "string",
            name: "string",
        }],
        operator: "string",
    },
    infraType: "string",
    orgId: "string",
    projectId: "string",
    description: "string",
    k8sSpec: {
        applicationSpec: {
            operator: "string",
            workloads: [{
                namespace: "string",
                applicationMapId: "string",
                kind: "string",
                label: "string",
                services: ["string"],
            }],
        },
        chaosServiceAccountSpec: {
            operator: "string",
            serviceAccounts: ["string"],
        },
        infraSpec: {
            infraIds: ["string"],
            operator: "string",
        },
    },
    machineSpec: {
        infraSpec: {
            infraIds: ["string"],
            operator: "string",
        },
    },
    name: "string",
    tags: ["string"],
});

type: harness:chaos:SecurityGovernanceCondition
properties:
    description: string
    faultSpec:
        faults:
            - faultType: string
              name: string
        operator: string
    infraType: string
    k8sSpec:
        applicationSpec:
            operator: string
            workloads:
                - applicationMapId: string
                  kind: string
                  label: string
                  namespace: string
                  services:
                    - string
        chaosServiceAccountSpec:
            operator: string
            serviceAccounts:
                - string
        infraSpec:
            infraIds:
                - string
            operator: string
    machineSpec:
        infraSpec:
            infraIds:
                - string
            operator: string
    name: string
    orgId: string
    projectId: string
    tags:
        - string