scm.getInterfaceManagementProfile

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

// 1. Resource: Create the Interface Management Profile
// This block creates the profile with your specified configuration.
const testInfMgmtProfile = new scm.InterfaceManagementProfile("test_inf_mgmt_profile", {
    name: "test_inf_mgmt_profile_ds_1",
    folder: "All",
    permittedIps: [
        {
            name: "10.0.0.0/24",
        },
        {
            name: "10.0.0.0/32",
        },
    ],
    http: true,
    https: false,
    telnet: false,
    ssh: true,
    ping: false,
    httpOcsp: true,
    useridService: true,
    useridSyslogListenerSsl: true,
    useridSyslogListenerUdp: true,
    responsePages: false,
});
// --------------------------------------------------------------------------------
// 2. Data Source: Retrieve the Interface Management Profile by ID
// We use the resource's generated 'id' attribute to fetch the profile.
const singleProfileById = scm.getInterfaceManagementProfileOutput({
    id: testInfMgmtProfile.id,
});
export const fetchedProfileName = singleProfileById.apply(singleProfileById => singleProfileById.name);
export const fetchedProfile = singleProfileById;

import pulumi
import pulumi_scm as scm

# 1. Resource: Create the Interface Management Profile
# This block creates the profile with your specified configuration.
test_inf_mgmt_profile = scm.InterfaceManagementProfile("test_inf_mgmt_profile",
    name="test_inf_mgmt_profile_ds_1",
    folder="All",
    permitted_ips=[
        {
            "name": "10.0.0.0/24",
        },
        {
            "name": "10.0.0.0/32",
        },
    ],
    http=True,
    https=False,
    telnet=False,
    ssh=True,
    ping=False,
    http_ocsp=True,
    userid_service=True,
    userid_syslog_listener_ssl=True,
    userid_syslog_listener_udp=True,
    response_pages=False)
# --------------------------------------------------------------------------------
# 2. Data Source: Retrieve the Interface Management Profile by ID
# We use the resource's generated 'id' attribute to fetch the profile.
single_profile_by_id = scm.get_interface_management_profile_output(id=test_inf_mgmt_profile.id)
pulumi.export("fetchedProfileName", single_profile_by_id.name)
pulumi.export("fetchedProfile", single_profile_by_id)

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// 1. Resource: Create the Interface Management Profile
		// This block creates the profile with your specified configuration.
		testInfMgmtProfile, err := scm.NewInterfaceManagementProfile(ctx, "test_inf_mgmt_profile", &scm.InterfaceManagementProfileArgs{
			Name:   pulumi.String("test_inf_mgmt_profile_ds_1"),
			Folder: pulumi.String("All"),
			PermittedIps: scm.InterfaceManagementProfilePermittedIpArray{
				&scm.InterfaceManagementProfilePermittedIpArgs{
					Name: pulumi.String("10.0.0.0/24"),
				},
				&scm.InterfaceManagementProfilePermittedIpArgs{
					Name: pulumi.String("10.0.0.0/32"),
				},
			},
			Http:                    pulumi.Bool(true),
			Https:                   pulumi.Bool(false),
			Telnet:                  pulumi.Bool(false),
			Ssh:                     pulumi.Bool(true),
			Ping:                    pulumi.Bool(false),
			HttpOcsp:                pulumi.Bool(true),
			UseridService:           pulumi.Bool(true),
			UseridSyslogListenerSsl: pulumi.Bool(true),
			UseridSyslogListenerUdp: pulumi.Bool(true),
			ResponsePages:           pulumi.Bool(false),
		})
		if err != nil {
			return err
		}
		// 2. Data Source: Retrieve the Interface Management Profile by ID
		// We use the resource's generated 'id' attribute to fetch the profile.
		singleProfileById := scm.LookupInterfaceManagementProfileOutput(ctx, scm.GetInterfaceManagementProfileOutputArgs{
			Id: testInfMgmtProfile.ID(),
		}, nil)
		ctx.Export("fetchedProfileName", singleProfileById.ApplyT(func(singleProfileById scm.GetInterfaceManagementProfileResult) (*string, error) {
			return &singleProfileById.Name, nil
		}).(pulumi.StringPtrOutput))
		ctx.Export("fetchedProfile", singleProfileById)
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    // 1. Resource: Create the Interface Management Profile
    // This block creates the profile with your specified configuration.
    var testInfMgmtProfile = new Scm.InterfaceManagementProfile("test_inf_mgmt_profile", new()
    {
        Name = "test_inf_mgmt_profile_ds_1",
        Folder = "All",
        PermittedIps = new[]
        {
            new Scm.Inputs.InterfaceManagementProfilePermittedIpArgs
            {
                Name = "10.0.0.0/24",
            },
            new Scm.Inputs.InterfaceManagementProfilePermittedIpArgs
            {
                Name = "10.0.0.0/32",
            },
        },
        Http = true,
        Https = false,
        Telnet = false,
        Ssh = true,
        Ping = false,
        HttpOcsp = true,
        UseridService = true,
        UseridSyslogListenerSsl = true,
        UseridSyslogListenerUdp = true,
        ResponsePages = false,
    });

    // --------------------------------------------------------------------------------
    // 2. Data Source: Retrieve the Interface Management Profile by ID
    // We use the resource's generated 'id' attribute to fetch the profile.
    var singleProfileById = Scm.GetInterfaceManagementProfile.Invoke(new()
    {
        Id = testInfMgmtProfile.Id,
    });

    return new Dictionary<string, object?>
    {
        ["fetchedProfileName"] = singleProfileById.Apply(getInterfaceManagementProfileResult => getInterfaceManagementProfileResult.Name),
        ["fetchedProfile"] = singleProfileById,
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.scm.InterfaceManagementProfile;
import com.pulumi.scm.InterfaceManagementProfileArgs;
import com.pulumi.scm.inputs.InterfaceManagementProfilePermittedIpArgs;
import com.pulumi.scm.ScmFunctions;
import com.pulumi.scm.inputs.GetInterfaceManagementProfileArgs;
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) {
        // 1. Resource: Create the Interface Management Profile
        // This block creates the profile with your specified configuration.
        var testInfMgmtProfile = new InterfaceManagementProfile("testInfMgmtProfile", InterfaceManagementProfileArgs.builder()
            .name("test_inf_mgmt_profile_ds_1")
            .folder("All")
            .permittedIps(            
                InterfaceManagementProfilePermittedIpArgs.builder()
                    .name("10.0.0.0/24")
                    .build(),
                InterfaceManagementProfilePermittedIpArgs.builder()
                    .name("10.0.0.0/32")
                    .build())
            .http(true)
            .https(false)
            .telnet(false)
            .ssh(true)
            .ping(false)
            .httpOcsp(true)
            .useridService(true)
            .useridSyslogListenerSsl(true)
            .useridSyslogListenerUdp(true)
            .responsePages(false)
            .build());

        // --------------------------------------------------------------------------------
        // 2. Data Source: Retrieve the Interface Management Profile by ID
        // We use the resource's generated 'id' attribute to fetch the profile.
        final var singleProfileById = ScmFunctions.getInterfaceManagementProfile(GetInterfaceManagementProfileArgs.builder()
            .id(testInfMgmtProfile.id())
            .build());

        ctx.export("fetchedProfileName", singleProfileById.applyValue(_singleProfileById -> _singleProfileById.name()));
        ctx.export("fetchedProfile", singleProfileById);
    }
}

resources:
  # 1. Resource: Create the Interface Management Profile
  # This block creates the profile with your specified configuration.
  testInfMgmtProfile: # --------------------------------------------------------------------------------
    type: scm:InterfaceManagementProfile
    name: test_inf_mgmt_profile
    properties:
      name: test_inf_mgmt_profile_ds_1
      folder: All
      permittedIps:
        - name: 10.0.0.0/24
        - name: 10.0.0.0/32
      http: true
      https: false
      telnet: false
      ssh: true
      ping: false
      httpOcsp: true
      useridService: true
      useridSyslogListenerSsl: true
      useridSyslogListenerUdp: true
      responsePages: false
variables:
  # 2. Data Source: Retrieve the Interface Management Profile by ID
  # We use the resource's generated 'id' attribute to fetch the profile.
  singleProfileById: # --------------------------------------------------------------------------------
    fn::invoke:
      function: scm:getInterfaceManagementProfile
      arguments:
        id: ${testInfMgmtProfile.id}
outputs:
  # 3. Output: Display a value from the fetched data source
  fetchedProfileName: ${singleProfileById.name}
  fetchedProfile: ${singleProfileById}

function getInterfaceManagementProfile(args: GetInterfaceManagementProfileArgs, opts?: InvokeOptions): Promise<GetInterfaceManagementProfileResult>
function getInterfaceManagementProfileOutput(args: GetInterfaceManagementProfileOutputArgs, opts?: InvokeOptions): Output<GetInterfaceManagementProfileResult>

def get_interface_management_profile(id: Optional[str] = None,
                                     name: Optional[str] = None,
                                     opts: Optional[InvokeOptions] = None) -> GetInterfaceManagementProfileResult
def get_interface_management_profile_output(id: Optional[pulumi.Input[str]] = None,
                                     name: Optional[pulumi.Input[str]] = None,
                                     opts: Optional[InvokeOptions] = None) -> Output[GetInterfaceManagementProfileResult]

func LookupInterfaceManagementProfile(ctx *Context, args *LookupInterfaceManagementProfileArgs, opts ...InvokeOption) (*LookupInterfaceManagementProfileResult, error)
func LookupInterfaceManagementProfileOutput(ctx *Context, args *LookupInterfaceManagementProfileOutputArgs, opts ...InvokeOption) LookupInterfaceManagementProfileResultOutput

public static class GetInterfaceManagementProfile 
{
    public static Task<GetInterfaceManagementProfileResult> InvokeAsync(GetInterfaceManagementProfileArgs args, InvokeOptions? opts = null)
    public static Output<GetInterfaceManagementProfileResult> Invoke(GetInterfaceManagementProfileInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetInterfaceManagementProfileResult> getInterfaceManagementProfile(GetInterfaceManagementProfileArgs args, InvokeOptions options)
public static Output<GetInterfaceManagementProfileResult> getInterfaceManagementProfile(GetInterfaceManagementProfileArgs args, InvokeOptions options)

fn::invoke:
  function: scm:index/getInterfaceManagementProfile:getInterfaceManagementProfile
  arguments:
    # arguments dictionary