sysdig.getSecureZone

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

const sample = new sysdig.SecureZone("sample", {
    description: "Test secure zone",
    scopes: [{
        targetType: "aws",
        rules: "organization in (\"o1\", \"o2\") and account in (\"a1\", \"a2\")",
    }],
});
const test = sysdig.getSecureZoneOutput({
    name: sample.name,
});

import pulumi
import pulumi_sysdig as sysdig

sample = sysdig.SecureZone("sample",
    description="Test secure zone",
    scopes=[{
        "target_type": "aws",
        "rules": "organization in (\"o1\", \"o2\") and account in (\"a1\", \"a2\")",
    }])
test = sysdig.get_secure_zone_output(name=sample.name)

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		sample, err := sysdig.NewSecureZone(ctx, "sample", &sysdig.SecureZoneArgs{
			Description: pulumi.String("Test secure zone"),
			Scopes: sysdig.SecureZoneScopeArray{
				&sysdig.SecureZoneScopeArgs{
					TargetType: pulumi.String("aws"),
					Rules:      pulumi.String("organization in (\"o1\", \"o2\") and account in (\"a1\", \"a2\")"),
				},
			},
		})
		if err != nil {
			return err
		}
		_ = sysdig.LookupSecureZoneOutput(ctx, sysdig.GetSecureZoneOutputArgs{
			Name: sample.Name,
		}, nil)
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var sample = new Sysdig.SecureZone("sample", new()
    {
        Description = "Test secure zone",
        Scopes = new[]
        {
            new Sysdig.Inputs.SecureZoneScopeArgs
            {
                TargetType = "aws",
                Rules = "organization in (\"o1\", \"o2\") and account in (\"a1\", \"a2\")",
            },
        },
    });

    var test = Sysdig.GetSecureZone.Invoke(new()
    {
        Name = sample.Name,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.sysdig.SecureZone;
import com.pulumi.sysdig.SecureZoneArgs;
import com.pulumi.sysdig.inputs.SecureZoneScopeArgs;
import com.pulumi.sysdig.SysdigFunctions;
import com.pulumi.sysdig.inputs.GetSecureZoneArgs;
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 sample = new SecureZone("sample", SecureZoneArgs.builder()
            .description("Test secure zone")
            .scopes(SecureZoneScopeArgs.builder()
                .targetType("aws")
                .rules("organization in (\"o1\", \"o2\") and account in (\"a1\", \"a2\")")
                .build())
            .build());

        final var test = SysdigFunctions.getSecureZone(GetSecureZoneArgs.builder()
            .name(sample.name())
            .build());

    }
}

resources:
  sample:
    type: sysdig:SecureZone
    properties:
      description: Test secure zone
      scopes:
        - targetType: aws
          rules: organization in ("o1", "o2") and account in ("a1", "a2")
variables:
  test:
    fn::invoke:
      function: sysdig:getSecureZone
      arguments:
        name: ${sample.name}

function getSecureZone(args: GetSecureZoneArgs, opts?: InvokeOptions): Promise<GetSecureZoneResult>
function getSecureZoneOutput(args: GetSecureZoneOutputArgs, opts?: InvokeOptions): Output<GetSecureZoneResult>

def get_secure_zone(id: Optional[str] = None,
                    name: Optional[str] = None,
                    opts: Optional[InvokeOptions] = None) -> GetSecureZoneResult
def get_secure_zone_output(id: Optional[pulumi.Input[str]] = None,
                    name: Optional[pulumi.Input[str]] = None,
                    opts: Optional[InvokeOptions] = None) -> Output[GetSecureZoneResult]

func LookupSecureZone(ctx *Context, args *LookupSecureZoneArgs, opts ...InvokeOption) (*LookupSecureZoneResult, error)
func LookupSecureZoneOutput(ctx *Context, args *LookupSecureZoneOutputArgs, opts ...InvokeOption) LookupSecureZoneResultOutput

public static class GetSecureZone 
{
    public static Task<GetSecureZoneResult> InvokeAsync(GetSecureZoneArgs args, InvokeOptions? opts = null)
    public static Output<GetSecureZoneResult> Invoke(GetSecureZoneInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetSecureZoneResult> getSecureZone(GetSecureZoneArgs args, InvokeOptions options)
public static Output<GetSecureZoneResult> getSecureZone(GetSecureZoneArgs args, InvokeOptions options)

fn::invoke:
  function: sysdig:index/getSecureZone:getSecureZone
  arguments:
    # arguments dictionary