newrelic.getAlertChannel

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

// Data source
const foo = newrelic.getAlertChannel({
    name: "foo@example.com",
});
// Resource
const fooAlertPolicy = new newrelic.AlertPolicy("foo", {name: "foo"});
// Using the data source and resource together
const fooAlertPolicyChannel = new newrelic.AlertPolicyChannel("foo", {
    policyId: fooAlertPolicy.id,
    channelId: foo.then(foo => foo.id),
});

import pulumi
import pulumi_newrelic as newrelic

# Data source
foo = newrelic.get_alert_channel(name="foo@example.com")
# Resource
foo_alert_policy = newrelic.AlertPolicy("foo", name="foo")
# Using the data source and resource together
foo_alert_policy_channel = newrelic.AlertPolicyChannel("foo",
    policy_id=foo_alert_policy.id,
    channel_id=foo.id)

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// Data source
		foo, err := newrelic.LookupAlertChannel(ctx, &newrelic.LookupAlertChannelArgs{
			Name: "foo@example.com",
		}, nil)
		if err != nil {
			return err
		}
		// Resource
		fooAlertPolicy, err := newrelic.NewAlertPolicy(ctx, "foo", &newrelic.AlertPolicyArgs{
			Name: pulumi.String("foo"),
		})
		if err != nil {
			return err
		}
		// Using the data source and resource together
		_, err = newrelic.NewAlertPolicyChannel(ctx, "foo", &newrelic.AlertPolicyChannelArgs{
			PolicyId:  fooAlertPolicy.ID(),
			ChannelId: foo.Id,
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    // Data source
    var foo = NewRelic.GetAlertChannel.Invoke(new()
    {
        Name = "foo@example.com",
    });

    // Resource
    var fooAlertPolicy = new NewRelic.AlertPolicy("foo", new()
    {
        Name = "foo",
    });

    // Using the data source and resource together
    var fooAlertPolicyChannel = new NewRelic.AlertPolicyChannel("foo", new()
    {
        PolicyId = fooAlertPolicy.Id,
        ChannelId = foo.Apply(getAlertChannelResult => getAlertChannelResult.Id),
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.newrelic.NewrelicFunctions;
import com.pulumi.newrelic.inputs.GetAlertChannelArgs;
import com.pulumi.newrelic.AlertPolicy;
import com.pulumi.newrelic.AlertPolicyArgs;
import com.pulumi.newrelic.AlertPolicyChannel;
import com.pulumi.newrelic.AlertPolicyChannelArgs;
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) {
        // Data source
        final var foo = NewrelicFunctions.getAlertChannel(GetAlertChannelArgs.builder()
            .name("foo@example.com")
            .build());

        // Resource
        var fooAlertPolicy = new AlertPolicy("fooAlertPolicy", AlertPolicyArgs.builder()
            .name("foo")
            .build());

        // Using the data source and resource together
        var fooAlertPolicyChannel = new AlertPolicyChannel("fooAlertPolicyChannel", AlertPolicyChannelArgs.builder()
            .policyId(fooAlertPolicy.id())
            .channelId(foo.id())
            .build());

    }
}

resources:
  # Resource
  fooAlertPolicy:
    type: newrelic:AlertPolicy
    name: foo
    properties:
      name: foo
  # Using the data source and resource together
  fooAlertPolicyChannel:
    type: newrelic:AlertPolicyChannel
    name: foo
    properties:
      policyId: ${fooAlertPolicy.id}
      channelId: ${foo.id}
variables:
  # Data source
  foo:
    fn::invoke:
      function: newrelic:getAlertChannel
      arguments:
        name: foo@example.com

function getAlertChannel(args: GetAlertChannelArgs, opts?: InvokeOptions): Promise<GetAlertChannelResult>
function getAlertChannelOutput(args: GetAlertChannelOutputArgs, opts?: InvokeOptions): Output<GetAlertChannelResult>

def get_alert_channel(account_id: Optional[str] = None,
                      name: Optional[str] = None,
                      opts: Optional[InvokeOptions] = None) -> GetAlertChannelResult
def get_alert_channel_output(account_id: Optional[pulumi.Input[str]] = None,
                      name: Optional[pulumi.Input[str]] = None,
                      opts: Optional[InvokeOptions] = None) -> Output[GetAlertChannelResult]

func LookupAlertChannel(ctx *Context, args *LookupAlertChannelArgs, opts ...InvokeOption) (*LookupAlertChannelResult, error)
func LookupAlertChannelOutput(ctx *Context, args *LookupAlertChannelOutputArgs, opts ...InvokeOption) LookupAlertChannelResultOutput

public static class GetAlertChannel 
{
    public static Task<GetAlertChannelResult> InvokeAsync(GetAlertChannelArgs args, InvokeOptions? opts = null)
    public static Output<GetAlertChannelResult> Invoke(GetAlertChannelInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetAlertChannelResult> getAlertChannel(GetAlertChannelArgs args, InvokeOptions options)
public static Output<GetAlertChannelResult> getAlertChannel(GetAlertChannelArgs args, InvokeOptions options)

fn::invoke:
  function: newrelic:index/getAlertChannel:getAlertChannel
  arguments:
    # arguments dictionary