Monitor

import * as pulumi from "@pulumi/pulumi";
import * as azure from "@pulumi/azure";
const example = new azure.core.ResourceGroup("example", {
    name: "example-resources",
    location: "East US",
});
const exampleMonitor = new azure.newrelic.Monitor("example", {
    name: "example-nrm",
    resourceGroupName: example.name,
    location: example.location,
    plan: {
        effectiveDate: "2023-06-06T00:00:00Z",
    },
    user: {
        email: "user@example.com",
        firstName: "Example",
        lastName: "User",
        phoneNumber: "+12313803556",
    },
    identity: {
        type: "SystemAssigned",
    },
});

import pulumi
import pulumi_azure as azure
example = azure.core.ResourceGroup("example",
    name="example-resources",
    location="East US")
example_monitor = azure.newrelic.Monitor("example",
    name="example-nrm",
    resource_group_name=example.name,
    location=example.location,
    plan={
        "effective_date": "2023-06-06T00:00:00Z",
    },
    user={
        "email": "user@example.com",
        "first_name": "Example",
        "last_name": "User",
        "phone_number": "+12313803556",
    },
    identity={
        "type": "SystemAssigned",
    })

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Azure = Pulumi.Azure;
return await Deployment.RunAsync(() =>
{
    var example = new Azure.Core.ResourceGroup("example", new()
    {
        Name = "example-resources",
        Location = "East US",
    });
    var exampleMonitor = new Azure.NewRelic.Monitor("example", new()
    {
        Name = "example-nrm",
        ResourceGroupName = example.Name,
        Location = example.Location,
        Plan = new Azure.NewRelic.Inputs.MonitorPlanArgs
        {
            EffectiveDate = "2023-06-06T00:00:00Z",
        },
        User = new Azure.NewRelic.Inputs.MonitorUserArgs
        {
            Email = "user@example.com",
            FirstName = "Example",
            LastName = "User",
            PhoneNumber = "+12313803556",
        },
        Identity = new Azure.NewRelic.Inputs.MonitorIdentityArgs
        {
            Type = "SystemAssigned",
        },
    });
});

package main
import (
	"github.com/pulumi/pulumi-azure/sdk/v6/go/azure/core"
	"github.com/pulumi/pulumi-azure/sdk/v6/go/azure/newrelic"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := core.NewResourceGroup(ctx, "example", &core.ResourceGroupArgs{
			Name:     pulumi.String("example-resources"),
			Location: pulumi.String("East US"),
		})
		if err != nil {
			return err
		}
		_, err = newrelic.NewMonitor(ctx, "example", &newrelic.MonitorArgs{
			Name:              pulumi.String("example-nrm"),
			ResourceGroupName: example.Name,
			Location:          example.Location,
			Plan: &newrelic.MonitorPlanArgs{
				EffectiveDate: pulumi.String("2023-06-06T00:00:00Z"),
			},
			User: &newrelic.MonitorUserArgs{
				Email:       pulumi.String("user@example.com"),
				FirstName:   pulumi.String("Example"),
				LastName:    pulumi.String("User"),
				PhoneNumber: pulumi.String("+12313803556"),
			},
			Identity: &newrelic.MonitorIdentityArgs{
				Type: pulumi.String("SystemAssigned"),
			},
		})
		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.azure.core.ResourceGroup;
import com.pulumi.azure.core.ResourceGroupArgs;
import com.pulumi.azure.newrelic.Monitor;
import com.pulumi.azure.newrelic.MonitorArgs;
import com.pulumi.azure.newrelic.inputs.MonitorPlanArgs;
import com.pulumi.azure.newrelic.inputs.MonitorUserArgs;
import com.pulumi.azure.newrelic.inputs.MonitorIdentityArgs;
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 example = new ResourceGroup("example", ResourceGroupArgs.builder()
            .name("example-resources")
            .location("East US")
            .build());
        var exampleMonitor = new Monitor("exampleMonitor", MonitorArgs.builder()
            .name("example-nrm")
            .resourceGroupName(example.name())
            .location(example.location())
            .plan(MonitorPlanArgs.builder()
                .effectiveDate("2023-06-06T00:00:00Z")
                .build())
            .user(MonitorUserArgs.builder()
                .email("user@example.com")
                .firstName("Example")
                .lastName("User")
                .phoneNumber("+12313803556")
                .build())
            .identity(MonitorIdentityArgs.builder()
                .type("SystemAssigned")
                .build())
            .build());
    }
}

resources:
  example:
    type: azure:core:ResourceGroup
    properties:
      name: example-resources
      location: East US
  exampleMonitor:
    type: azure:newrelic:Monitor
    name: example
    properties:
      name: example-nrm
      resourceGroupName: ${example.name}
      location: ${example.location}
      plan:
        effectiveDate: 2023-06-06T00:00:00Z
      user:
        email: user@example.com
        firstName: Example
        lastName: User
        phoneNumber: '+12313803556'
      identity:
        type: SystemAssigned

import * as pulumi from "@pulumi/pulumi";
import * as azure from "@pulumi/azure";
const primary = azure.core.getSubscription({});
const monitoringReader = azure.authorization.getRoleDefinition({
    name: "Monitoring Reader",
});
const example = new azure.authorization.Assignment("example", {
    scope: primary.then(primary => primary.id),
    roleDefinitionId: Promise.all([primary, monitoringReader]).then(([primary, monitoringReader]) => `${primary.id}${monitoringReader.id}`),
    principalId: exampleAzurermNewRelicMonitor.identity[0].principalId,
});

import pulumi
import pulumi_azure as azure
primary = azure.core.get_subscription()
monitoring_reader = azure.authorization.get_role_definition(name="Monitoring Reader")
example = azure.authorization.Assignment("example",
    scope=primary.id,
    role_definition_id=f"{primary.id}{monitoring_reader.id}",
    principal_id=example_azurerm_new_relic_monitor["identity"][0]["principalId"])

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Azure = Pulumi.Azure;
return await Deployment.RunAsync(() =>
{
    var primary = Azure.Core.GetSubscription.Invoke();
    var monitoringReader = Azure.Authorization.GetRoleDefinition.Invoke(new()
    {
        Name = "Monitoring Reader",
    });
    var example = new Azure.Authorization.Assignment("example", new()
    {
        Scope = primary.Apply(getSubscriptionResult => getSubscriptionResult.Id),
        RoleDefinitionId = Output.Tuple(primary, monitoringReader).Apply(values =>
        {
            var primary = values.Item1;
            var monitoringReader = values.Item2;
            return $"{primary.Apply(getSubscriptionResult => getSubscriptionResult.Id)}{monitoringReader.Apply(getRoleDefinitionResult => getRoleDefinitionResult.Id)}";
        }),
        PrincipalId = exampleAzurermNewRelicMonitor.Identity[0].PrincipalId,
    });
});

package main
import (
	"fmt"
	"github.com/pulumi/pulumi-azure/sdk/v6/go/azure/authorization"
	"github.com/pulumi/pulumi-azure/sdk/v6/go/azure/core"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		primary, err := core.LookupSubscription(ctx, &core.LookupSubscriptionArgs{}, nil)
		if err != nil {
			return err
		}
		monitoringReader, err := authorization.LookupRoleDefinition(ctx, &authorization.LookupRoleDefinitionArgs{
			Name: pulumi.StringRef("Monitoring Reader"),
		}, nil)
		if err != nil {
			return err
		}
		_, err = authorization.NewAssignment(ctx, "example", &authorization.AssignmentArgs{
			Scope:            pulumi.String(primary.Id),
			RoleDefinitionId: pulumi.Sprintf("%v%v", primary.Id, monitoringReader.Id),
			PrincipalId:      pulumi.Any(exampleAzurermNewRelicMonitor.Identity[0].PrincipalId),
		})
		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.azure.core.CoreFunctions;
import com.pulumi.azure.core.inputs.GetSubscriptionArgs;
import com.pulumi.azure.authorization.AuthorizationFunctions;
import com.pulumi.azure.authorization.inputs.GetRoleDefinitionArgs;
import com.pulumi.azure.authorization.Assignment;
import com.pulumi.azure.authorization.AssignmentArgs;
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 primary = CoreFunctions.getSubscription(GetSubscriptionArgs.builder()
            .build());
        final var monitoringReader = AuthorizationFunctions.getRoleDefinition(GetRoleDefinitionArgs.builder()
            .name("Monitoring Reader")
            .build());
        var example = new Assignment("example", AssignmentArgs.builder()
            .scope(primary.id())
            .roleDefinitionId(String.format("%s%s", primary.id(),monitoringReader.id()))
            .principalId(exampleAzurermNewRelicMonitor.identity()[0].principalId())
            .build());
    }
}

resources:
  example:
    type: azure:authorization:Assignment
    properties:
      scope: ${primary.id}
      roleDefinitionId: ${primary.id}${monitoringReader.id}
      principalId: ${exampleAzurermNewRelicMonitor.identity[0].principalId}
variables:
  primary:
    fn::invoke:
      function: azure:core:getSubscription
      arguments: {}
  monitoringReader:
    fn::invoke:
      function: azure:authorization:getRoleDefinition
      arguments:
        name: Monitoring Reader

$ pulumi import azure:newrelic/monitor:Monitor example /subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup1/providers/NewRelic.Observability/monitors/monitor1