edgecenter.getInstancePortSecurity

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

const pr = edgecenter.getProject({
    name: "test",
});
const rg = edgecenter.getRegion({
    name: "ED-10 Preprod",
});
const portSecurity = Promise.all([rg, pr]).then(([rg, pr]) => edgecenter.getInstancePortSecurity({
    regionId: rg.id,
    projectId: pr.id,
    portId: "073947f8-8589-4104-bdff-2cedbe56239f",
    instanceId: "4f81e8f8-d7b8-45a4-93fd-609ad2n670f0",
}));
export const view = portSecurity;

import pulumi
import pulumi_edgecenter as edgecenter

pr = edgecenter.get_project(name="test")
rg = edgecenter.get_region(name="ED-10 Preprod")
port_security = edgecenter.get_instance_port_security(region_id=rg.id,
    project_id=pr.id,
    port_id="073947f8-8589-4104-bdff-2cedbe56239f",
    instance_id="4f81e8f8-d7b8-45a4-93fd-609ad2n670f0")
pulumi.export("view", port_security)

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		pr, err := edgecenter.LookupProject(ctx, &edgecenter.LookupProjectArgs{
			Name: pulumi.StringRef("test"),
		}, nil)
		if err != nil {
			return err
		}
		rg, err := edgecenter.GetRegion(ctx, &edgecenter.GetRegionArgs{
			Name: "ED-10 Preprod",
		}, nil)
		if err != nil {
			return err
		}
		portSecurity, err := edgecenter.LookupInstancePortSecurity(ctx, &edgecenter.LookupInstancePortSecurityArgs{
			RegionId:   pulumi.Float64Ref(rg.Id),
			ProjectId:  pulumi.Float64Ref(pr.Id),
			PortId:     "073947f8-8589-4104-bdff-2cedbe56239f",
			InstanceId: "4f81e8f8-d7b8-45a4-93fd-609ad2n670f0",
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("view", portSecurity)
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var pr = Edgecenter.GetProject.Invoke(new()
    {
        Name = "test",
    });

    var rg = Edgecenter.GetRegion.Invoke(new()
    {
        Name = "ED-10 Preprod",
    });

    var portSecurity = Edgecenter.GetInstancePortSecurity.Invoke(new()
    {
        RegionId = rg.Apply(getRegionResult => getRegionResult.Id),
        ProjectId = pr.Apply(getProjectResult => getProjectResult.Id),
        PortId = "073947f8-8589-4104-bdff-2cedbe56239f",
        InstanceId = "4f81e8f8-d7b8-45a4-93fd-609ad2n670f0",
    });

    return new Dictionary<string, object?>
    {
        ["view"] = portSecurity,
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.edgecenter.EdgecenterFunctions;
import com.pulumi.edgecenter.inputs.GetProjectArgs;
import com.pulumi.edgecenter.inputs.GetRegionArgs;
import com.pulumi.edgecenter.inputs.GetInstancePortSecurityArgs;
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) {
        final var pr = EdgecenterFunctions.getProject(GetProjectArgs.builder()
            .name("test")
            .build());

        final var rg = EdgecenterFunctions.getRegion(GetRegionArgs.builder()
            .name("ED-10 Preprod")
            .build());

        final var portSecurity = EdgecenterFunctions.getInstancePortSecurity(GetInstancePortSecurityArgs.builder()
            .regionId(rg.applyValue(getRegionResult -> getRegionResult.id()))
            .projectId(pr.applyValue(getProjectResult -> getProjectResult.id()))
            .portId("073947f8-8589-4104-bdff-2cedbe56239f")
            .instanceId("4f81e8f8-d7b8-45a4-93fd-609ad2n670f0")
            .build());

        ctx.export("view", portSecurity.applyValue(getInstancePortSecurityResult -> getInstancePortSecurityResult));
    }
}

variables:
  pr:
    fn::invoke:
      function: edgecenter:getProject
      arguments:
        name: test
  rg:
    fn::invoke:
      function: edgecenter:getRegion
      arguments:
        name: ED-10 Preprod
  portSecurity:
    fn::invoke:
      function: edgecenter:getInstancePortSecurity
      arguments:
        regionId: ${rg.id}
        projectId: ${pr.id}
        portId: 073947f8-8589-4104-bdff-2cedbe56239f
        instanceId: 4f81e8f8-d7b8-45a4-93fd-609ad2n670f0
outputs:
  view: ${portSecurity}

function getInstancePortSecurity(args: GetInstancePortSecurityArgs, opts?: InvokeOptions): Promise<GetInstancePortSecurityResult>
function getInstancePortSecurityOutput(args: GetInstancePortSecurityOutputArgs, opts?: InvokeOptions): Output<GetInstancePortSecurityResult>

def get_instance_port_security(id: Optional[str] = None,
                               instance_id: Optional[str] = None,
                               port_id: Optional[str] = None,
                               project_id: Optional[float] = None,
                               project_name: Optional[str] = None,
                               region_id: Optional[float] = None,
                               region_name: Optional[str] = None,
                               opts: Optional[InvokeOptions] = None) -> GetInstancePortSecurityResult
def get_instance_port_security_output(id: Optional[pulumi.Input[str]] = None,
                               instance_id: Optional[pulumi.Input[str]] = None,
                               port_id: Optional[pulumi.Input[str]] = None,
                               project_id: Optional[pulumi.Input[float]] = None,
                               project_name: Optional[pulumi.Input[str]] = None,
                               region_id: Optional[pulumi.Input[float]] = None,
                               region_name: Optional[pulumi.Input[str]] = None,
                               opts: Optional[InvokeOptions] = None) -> Output[GetInstancePortSecurityResult]

func LookupInstancePortSecurity(ctx *Context, args *LookupInstancePortSecurityArgs, opts ...InvokeOption) (*LookupInstancePortSecurityResult, error)
func LookupInstancePortSecurityOutput(ctx *Context, args *LookupInstancePortSecurityOutputArgs, opts ...InvokeOption) LookupInstancePortSecurityResultOutput

public static class GetInstancePortSecurity 
{
    public static Task<GetInstancePortSecurityResult> InvokeAsync(GetInstancePortSecurityArgs args, InvokeOptions? opts = null)
    public static Output<GetInstancePortSecurityResult> Invoke(GetInstancePortSecurityInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetInstancePortSecurityResult> getInstancePortSecurity(GetInstancePortSecurityArgs args, InvokeOptions options)
public static Output<GetInstancePortSecurityResult> getInstancePortSecurity(GetInstancePortSecurityArgs args, InvokeOptions options)

fn::invoke:
  function: edgecenter:index/getInstancePortSecurity:getInstancePortSecurity
  arguments:
    # arguments dictionary