newrelic.AlertPolicyChannel

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

return await Deployment.RunAsync(() => 
{
    var examplePolicy = NewRelic.GetAlertPolicy.Invoke(new()
    {
        Name = "my-alert-policy",
    });

    // Creates an email alert channel.
    var emailChannel = new NewRelic.AlertChannel("emailChannel", new()
    {
        Type = "email",
        Config = new NewRelic.Inputs.AlertChannelConfigArgs
        {
            Recipients = "foo@example.com",
            IncludeJsonAttachment = "1",
        },
    });

    // Creates a Slack alert channel.
    var slackChannel = new NewRelic.AlertChannel("slackChannel", new()
    {
        Type = "slack",
        Config = new NewRelic.Inputs.AlertChannelConfigArgs
        {
            Channel = "#example-channel",
            Url = "http://example-org.slack.com",
        },
    });

    // Applies the created channels above to the alert policy
    // referenced at the top of the config.
    var foo = new NewRelic.AlertPolicyChannel("foo", new()
    {
        PolicyId = examplePolicy.Apply(getAlertPolicyResult => getAlertPolicyResult.Id),
        ChannelIds = new[]
        {
            emailChannel.Id,
            slackChannel.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 {
		examplePolicy, err := newrelic.LookupAlertPolicy(ctx, &newrelic.LookupAlertPolicyArgs{
			Name: "my-alert-policy",
		}, nil)
		if err != nil {
			return err
		}
		emailChannel, err := newrelic.NewAlertChannel(ctx, "emailChannel", &newrelic.AlertChannelArgs{
			Type: pulumi.String("email"),
			Config: &newrelic.AlertChannelConfigArgs{
				Recipients:            pulumi.String("foo@example.com"),
				IncludeJsonAttachment: pulumi.String("1"),
			},
		})
		if err != nil {
			return err
		}
		slackChannel, err := newrelic.NewAlertChannel(ctx, "slackChannel", &newrelic.AlertChannelArgs{
			Type: pulumi.String("slack"),
			Config: &newrelic.AlertChannelConfigArgs{
				Channel: pulumi.String("#example-channel"),
				Url:     pulumi.String("http://example-org.slack.com"),
			},
		})
		if err != nil {
			return err
		}
		_, err = newrelic.NewAlertPolicyChannel(ctx, "foo", &newrelic.AlertPolicyChannelArgs{
			PolicyId: *pulumi.String(examplePolicy.Id),
			ChannelIds: pulumi.IntArray{
				emailChannel.ID(),
				slackChannel.ID(),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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.GetAlertPolicyArgs;
import com.pulumi.newrelic.AlertChannel;
import com.pulumi.newrelic.AlertChannelArgs;
import com.pulumi.newrelic.inputs.AlertChannelConfigArgs;
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) {
        final var examplePolicy = NewrelicFunctions.getAlertPolicy(GetAlertPolicyArgs.builder()
            .name("my-alert-policy")
            .build());

        var emailChannel = new AlertChannel("emailChannel", AlertChannelArgs.builder()        
            .type("email")
            .config(AlertChannelConfigArgs.builder()
                .recipients("foo@example.com")
                .includeJsonAttachment("1")
                .build())
            .build());

        var slackChannel = new AlertChannel("slackChannel", AlertChannelArgs.builder()        
            .type("slack")
            .config(AlertChannelConfigArgs.builder()
                .channel("#example-channel")
                .url("http://example-org.slack.com")
                .build())
            .build());

        var foo = new AlertPolicyChannel("foo", AlertPolicyChannelArgs.builder()        
            .policyId(examplePolicy.applyValue(getAlertPolicyResult -> getAlertPolicyResult.id()))
            .channelIds(            
                emailChannel.id(),
                slackChannel.id())
            .build());

    }
}

import pulumi
import pulumi_newrelic as newrelic

example_policy = newrelic.get_alert_policy(name="my-alert-policy")
# Creates an email alert channel.
email_channel = newrelic.AlertChannel("emailChannel",
    type="email",
    config=newrelic.AlertChannelConfigArgs(
        recipients="foo@example.com",
        include_json_attachment="1",
    ))
# Creates a Slack alert channel.
slack_channel = newrelic.AlertChannel("slackChannel",
    type="slack",
    config=newrelic.AlertChannelConfigArgs(
        channel="#example-channel",
        url="http://example-org.slack.com",
    ))
# Applies the created channels above to the alert policy
# referenced at the top of the config.
foo = newrelic.AlertPolicyChannel("foo",
    policy_id=example_policy.id,
    channel_ids=[
        email_channel.id,
        slack_channel.id,
    ])

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

const examplePolicy = newrelic.getAlertPolicy({
    name: "my-alert-policy",
});
// Creates an email alert channel.
const emailChannel = new newrelic.AlertChannel("emailChannel", {
    type: "email",
    config: {
        recipients: "foo@example.com",
        includeJsonAttachment: "1",
    },
});
// Creates a Slack alert channel.
const slackChannel = new newrelic.AlertChannel("slackChannel", {
    type: "slack",
    config: {
        channel: "#example-channel",
        url: "http://example-org.slack.com",
    },
});
// Applies the created channels above to the alert policy
// referenced at the top of the config.
const foo = new newrelic.AlertPolicyChannel("foo", {
    policyId: examplePolicy.then(examplePolicy => examplePolicy.id),
    channelIds: [
        emailChannel.id,
        slackChannel.id,
    ],
});

resources:
  # Creates an email alert channel.
  emailChannel:
    type: newrelic:AlertChannel
    properties:
      type: email
      config:
        recipients: foo@example.com
        includeJsonAttachment: '1'
  # Creates a Slack alert channel.
  slackChannel:
    type: newrelic:AlertChannel
    properties:
      type: slack
      config:
        channel: '#example-channel'
        url: http://example-org.slack.com
  # Applies the created channels above to the alert policy
  # referenced at the top of the config.
  foo:
    type: newrelic:AlertPolicyChannel
    properties:
      policyId: ${examplePolicy.id}
      channelIds:
        - ${emailChannel.id}
        - ${slackChannel.id}
variables:
  examplePolicy:
    fn::invoke:
      Function: newrelic:getAlertPolicy
      Arguments:
        name: my-alert-policy