newrelic.cloud.AzureIntegrations

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

const foo = new newrelic.cloud.AzureLinkAccount("foo", {
    accountId: "The New Relic account ID where you want to link the Azure account",
    applicationId: "ID of the application",
    clientSecret: "Secret value of client's Azure account",
    subscriptionId: "Subscription ID of Azure",
    tenantId: "Tenant ID of the Azure",
    name: "Name of the linked account",
});
const fooAzureIntegrations = new newrelic.cloud.AzureIntegrations("foo", {
    linkedAccountId: foo.id,
    accountId: "The New Relic account ID",
    apiManagement: {
        metricsPollingInterval: 300,
        resourceGroups: ["resource_groups"],
    },
    appGateway: {
        metricsPollingInterval: 300,
        resourceGroups: ["resource_groups"],
    },
    appService: {
        metricsPollingInterval: 300,
        resourceGroups: ["resource_groups"],
    },
    containers: {
        metricsPollingInterval: 300,
        resourceGroups: ["resource_groups"],
    },
    cosmosDb: {
        metricsPollingInterval: 300,
        resourceGroups: ["resource_groups"],
    },
    costManagement: {
        metricsPollingInterval: 3600,
        tagKeys: ["tag_keys"],
    },
    dataFactory: {
        metricsPollingInterval: 300,
        resourceGroups: ["resource_groups"],
    },
    eventHub: {
        metricsPollingInterval: 300,
        resourceGroups: ["resource_groups"],
    },
    expressRoute: {
        metricsPollingInterval: 300,
        resourceGroups: ["resource_groups"],
    },
    firewalls: {
        metricsPollingInterval: 300,
        resourceGroups: ["resource_groups"],
    },
    frontDoor: {
        metricsPollingInterval: 300,
        resourceGroups: ["resource_groups"],
    },
    functions: {
        metricsPollingInterval: 300,
        resourceGroups: ["resource_groups"],
    },
    keyVault: {
        metricsPollingInterval: 300,
        resourceGroups: ["resource_groups"],
    },
    loadBalancer: {
        metricsPollingInterval: 300,
        resourceGroups: ["resource_groups"],
    },
    logicApps: {
        metricsPollingInterval: 300,
        resourceGroups: ["resource_groups"],
    },
    machineLearning: {
        metricsPollingInterval: 300,
        resourceGroups: ["resource_groups"],
    },
    mariaDb: {
        metricsPollingInterval: 3600,
        resourceGroups: ["resource_groups"],
    },
    monitor: {
        metricsPollingInterval: 60,
        resourceGroups: ["resource_groups"],
        includeTags: ["env:production"],
        excludeTags: [
            "env:staging",
            "env:testing",
        ],
        enabled: true,
        resourceTypes: ["microsoft.datashare/accounts"],
    },
    mysql: {
        metricsPollingInterval: 3600,
        resourceGroups: ["resource_groups"],
    },
    mysqlFlexible: {
        metricsPollingInterval: 3600,
        resourceGroups: ["resource_groups"],
    },
    postgresql: {
        metricsPollingInterval: 3600,
        resourceGroups: ["resource_groups"],
    },
    postgresqlFlexible: {
        metricsPollingInterval: 3600,
        resourceGroups: ["resource_groups"],
    },
    powerBiDedicated: {
        metricsPollingInterval: 300,
        resourceGroups: ["resource_groups"],
    },
    redisCache: {
        metricsPollingInterval: 300,
        resourceGroups: ["resource_groups"],
    },
    serviceBus: {
        metricsPollingInterval: 300,
        resourceGroups: ["resource_groups"],
    },
    sql: {
        metricsPollingInterval: 300,
        resourceGroups: ["resource_groups"],
    },
    sqlManaged: {
        metricsPollingInterval: 300,
        resourceGroups: ["resource_groups"],
    },
    storage: {
        metricsPollingInterval: 1800,
        resourceGroups: ["resource_groups"],
    },
    virtualMachine: {
        metricsPollingInterval: 300,
        resourceGroups: ["resource_groups"],
    },
    virtualNetworks: {
        metricsPollingInterval: 300,
        resourceGroups: ["resource_groups"],
    },
    vms: {
        metricsPollingInterval: 300,
        resourceGroups: ["resource_groups"],
    },
    vpnGateway: {
        metricsPollingInterval: 300,
        resourceGroups: ["resource_groups"],
    },
});

import pulumi
import pulumi_newrelic as newrelic

foo = newrelic.cloud.AzureLinkAccount("foo",
    account_id="The New Relic account ID where you want to link the Azure account",
    application_id="ID of the application",
    client_secret="Secret value of client's Azure account",
    subscription_id="Subscription ID of Azure",
    tenant_id="Tenant ID of the Azure",
    name="Name of the linked account")
foo_azure_integrations = newrelic.cloud.AzureIntegrations("foo",
    linked_account_id=foo.id,
    account_id="The New Relic account ID",
    api_management={
        "metrics_polling_interval": 300,
        "resource_groups": ["resource_groups"],
    },
    app_gateway={
        "metrics_polling_interval": 300,
        "resource_groups": ["resource_groups"],
    },
    app_service={
        "metrics_polling_interval": 300,
        "resource_groups": ["resource_groups"],
    },
    containers={
        "metrics_polling_interval": 300,
        "resource_groups": ["resource_groups"],
    },
    cosmos_db={
        "metrics_polling_interval": 300,
        "resource_groups": ["resource_groups"],
    },
    cost_management={
        "metrics_polling_interval": 3600,
        "tag_keys": ["tag_keys"],
    },
    data_factory={
        "metrics_polling_interval": 300,
        "resource_groups": ["resource_groups"],
    },
    event_hub={
        "metrics_polling_interval": 300,
        "resource_groups": ["resource_groups"],
    },
    express_route={
        "metrics_polling_interval": 300,
        "resource_groups": ["resource_groups"],
    },
    firewalls={
        "metrics_polling_interval": 300,
        "resource_groups": ["resource_groups"],
    },
    front_door={
        "metrics_polling_interval": 300,
        "resource_groups": ["resource_groups"],
    },
    functions={
        "metrics_polling_interval": 300,
        "resource_groups": ["resource_groups"],
    },
    key_vault={
        "metrics_polling_interval": 300,
        "resource_groups": ["resource_groups"],
    },
    load_balancer={
        "metrics_polling_interval": 300,
        "resource_groups": ["resource_groups"],
    },
    logic_apps={
        "metrics_polling_interval": 300,
        "resource_groups": ["resource_groups"],
    },
    machine_learning={
        "metrics_polling_interval": 300,
        "resource_groups": ["resource_groups"],
    },
    maria_db={
        "metrics_polling_interval": 3600,
        "resource_groups": ["resource_groups"],
    },
    monitor={
        "metrics_polling_interval": 60,
        "resource_groups": ["resource_groups"],
        "include_tags": ["env:production"],
        "exclude_tags": [
            "env:staging",
            "env:testing",
        ],
        "enabled": True,
        "resource_types": ["microsoft.datashare/accounts"],
    },
    mysql={
        "metrics_polling_interval": 3600,
        "resource_groups": ["resource_groups"],
    },
    mysql_flexible={
        "metrics_polling_interval": 3600,
        "resource_groups": ["resource_groups"],
    },
    postgresql={
        "metrics_polling_interval": 3600,
        "resource_groups": ["resource_groups"],
    },
    postgresql_flexible={
        "metrics_polling_interval": 3600,
        "resource_groups": ["resource_groups"],
    },
    power_bi_dedicated={
        "metrics_polling_interval": 300,
        "resource_groups": ["resource_groups"],
    },
    redis_cache={
        "metrics_polling_interval": 300,
        "resource_groups": ["resource_groups"],
    },
    service_bus={
        "metrics_polling_interval": 300,
        "resource_groups": ["resource_groups"],
    },
    sql={
        "metrics_polling_interval": 300,
        "resource_groups": ["resource_groups"],
    },
    sql_managed={
        "metrics_polling_interval": 300,
        "resource_groups": ["resource_groups"],
    },
    storage={
        "metrics_polling_interval": 1800,
        "resource_groups": ["resource_groups"],
    },
    virtual_machine={
        "metrics_polling_interval": 300,
        "resource_groups": ["resource_groups"],
    },
    virtual_networks={
        "metrics_polling_interval": 300,
        "resource_groups": ["resource_groups"],
    },
    vms={
        "metrics_polling_interval": 300,
        "resource_groups": ["resource_groups"],
    },
    vpn_gateway={
        "metrics_polling_interval": 300,
        "resource_groups": ["resource_groups"],
    })

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		foo, err := cloud.NewAzureLinkAccount(ctx, "foo", &cloud.AzureLinkAccountArgs{
			AccountId:      pulumi.String("The New Relic account ID where you want to link the Azure account"),
			ApplicationId:  pulumi.String("ID of the application"),
			ClientSecret:   pulumi.String("Secret value of client's Azure account"),
			SubscriptionId: pulumi.String("Subscription ID of Azure"),
			TenantId:       pulumi.String("Tenant ID of the Azure"),
			Name:           pulumi.String("Name of the linked account"),
		})
		if err != nil {
			return err
		}
		_, err = cloud.NewAzureIntegrations(ctx, "foo", &cloud.AzureIntegrationsArgs{
			LinkedAccountId: foo.ID(),
			AccountId:       pulumi.String("The New Relic account ID"),
			ApiManagement: &cloud.AzureIntegrationsApiManagementArgs{
				MetricsPollingInterval: pulumi.Int(300),
				ResourceGroups: pulumi.StringArray{
					pulumi.String("resource_groups"),
				},
			},
			AppGateway: &cloud.AzureIntegrationsAppGatewayArgs{
				MetricsPollingInterval: pulumi.Int(300),
				ResourceGroups: pulumi.StringArray{
					pulumi.String("resource_groups"),
				},
			},
			AppService: &cloud.AzureIntegrationsAppServiceArgs{
				MetricsPollingInterval: pulumi.Int(300),
				ResourceGroups: pulumi.StringArray{
					pulumi.String("resource_groups"),
				},
			},
			Containers: &cloud.AzureIntegrationsContainersArgs{
				MetricsPollingInterval: pulumi.Int(300),
				ResourceGroups: pulumi.StringArray{
					pulumi.String("resource_groups"),
				},
			},
			CosmosDb: &cloud.AzureIntegrationsCosmosDbArgs{
				MetricsPollingInterval: pulumi.Int(300),
				ResourceGroups: pulumi.StringArray{
					pulumi.String("resource_groups"),
				},
			},
			CostManagement: &cloud.AzureIntegrationsCostManagementArgs{
				MetricsPollingInterval: pulumi.Int(3600),
				TagKeys: pulumi.StringArray{
					pulumi.String("tag_keys"),
				},
			},
			DataFactory: &cloud.AzureIntegrationsDataFactoryArgs{
				MetricsPollingInterval: pulumi.Int(300),
				ResourceGroups: pulumi.StringArray{
					pulumi.String("resource_groups"),
				},
			},
			EventHub: &cloud.AzureIntegrationsEventHubArgs{
				MetricsPollingInterval: pulumi.Int(300),
				ResourceGroups: pulumi.StringArray{
					pulumi.String("resource_groups"),
				},
			},
			ExpressRoute: &cloud.AzureIntegrationsExpressRouteArgs{
				MetricsPollingInterval: pulumi.Int(300),
				ResourceGroups: pulumi.StringArray{
					pulumi.String("resource_groups"),
				},
			},
			Firewalls: &cloud.AzureIntegrationsFirewallsArgs{
				MetricsPollingInterval: pulumi.Int(300),
				ResourceGroups: pulumi.StringArray{
					pulumi.String("resource_groups"),
				},
			},
			FrontDoor: &cloud.AzureIntegrationsFrontDoorArgs{
				MetricsPollingInterval: pulumi.Int(300),
				ResourceGroups: pulumi.StringArray{
					pulumi.String("resource_groups"),
				},
			},
			Functions: &cloud.AzureIntegrationsFunctionsArgs{
				MetricsPollingInterval: pulumi.Int(300),
				ResourceGroups: pulumi.StringArray{
					pulumi.String("resource_groups"),
				},
			},
			KeyVault: &cloud.AzureIntegrationsKeyVaultArgs{
				MetricsPollingInterval: pulumi.Int(300),
				ResourceGroups: pulumi.StringArray{
					pulumi.String("resource_groups"),
				},
			},
			LoadBalancer: &cloud.AzureIntegrationsLoadBalancerArgs{
				MetricsPollingInterval: pulumi.Int(300),
				ResourceGroups: pulumi.StringArray{
					pulumi.String("resource_groups"),
				},
			},
			LogicApps: &cloud.AzureIntegrationsLogicAppsArgs{
				MetricsPollingInterval: pulumi.Int(300),
				ResourceGroups: pulumi.StringArray{
					pulumi.String("resource_groups"),
				},
			},
			MachineLearning: &cloud.AzureIntegrationsMachineLearningArgs{
				MetricsPollingInterval: pulumi.Int(300),
				ResourceGroups: pulumi.StringArray{
					pulumi.String("resource_groups"),
				},
			},
			MariaDb: &cloud.AzureIntegrationsMariaDbArgs{
				MetricsPollingInterval: pulumi.Int(3600),
				ResourceGroups: pulumi.StringArray{
					pulumi.String("resource_groups"),
				},
			},
			Monitor: &cloud.AzureIntegrationsMonitorArgs{
				MetricsPollingInterval: pulumi.Int(60),
				ResourceGroups: pulumi.StringArray{
					pulumi.String("resource_groups"),
				},
				IncludeTags: pulumi.StringArray{
					pulumi.String("env:production"),
				},
				ExcludeTags: pulumi.StringArray{
					pulumi.String("env:staging"),
					pulumi.String("env:testing"),
				},
				Enabled: pulumi.Bool(true),
				ResourceTypes: pulumi.StringArray{
					pulumi.String("microsoft.datashare/accounts"),
				},
			},
			Mysql: &cloud.AzureIntegrationsMysqlArgs{
				MetricsPollingInterval: pulumi.Int(3600),
				ResourceGroups: pulumi.StringArray{
					pulumi.String("resource_groups"),
				},
			},
			MysqlFlexible: &cloud.AzureIntegrationsMysqlFlexibleArgs{
				MetricsPollingInterval: pulumi.Int(3600),
				ResourceGroups: pulumi.StringArray{
					pulumi.String("resource_groups"),
				},
			},
			Postgresql: &cloud.AzureIntegrationsPostgresqlArgs{
				MetricsPollingInterval: pulumi.Int(3600),
				ResourceGroups: pulumi.StringArray{
					pulumi.String("resource_groups"),
				},
			},
			PostgresqlFlexible: &cloud.AzureIntegrationsPostgresqlFlexibleArgs{
				MetricsPollingInterval: pulumi.Int(3600),
				ResourceGroups: pulumi.StringArray{
					pulumi.String("resource_groups"),
				},
			},
			PowerBiDedicated: &cloud.AzureIntegrationsPowerBiDedicatedArgs{
				MetricsPollingInterval: pulumi.Int(300),
				ResourceGroups: pulumi.StringArray{
					pulumi.String("resource_groups"),
				},
			},
			RedisCache: &cloud.AzureIntegrationsRedisCacheArgs{
				MetricsPollingInterval: pulumi.Int(300),
				ResourceGroups: pulumi.StringArray{
					pulumi.String("resource_groups"),
				},
			},
			ServiceBus: &cloud.AzureIntegrationsServiceBusArgs{
				MetricsPollingInterval: pulumi.Int(300),
				ResourceGroups: pulumi.StringArray{
					pulumi.String("resource_groups"),
				},
			},
			Sql: &cloud.AzureIntegrationsSqlArgs{
				MetricsPollingInterval: pulumi.Int(300),
				ResourceGroups: pulumi.StringArray{
					pulumi.String("resource_groups"),
				},
			},
			SqlManaged: &cloud.AzureIntegrationsSqlManagedArgs{
				MetricsPollingInterval: pulumi.Int(300),
				ResourceGroups: pulumi.StringArray{
					pulumi.String("resource_groups"),
				},
			},
			Storage: &cloud.AzureIntegrationsStorageArgs{
				MetricsPollingInterval: pulumi.Int(1800),
				ResourceGroups: pulumi.StringArray{
					pulumi.String("resource_groups"),
				},
			},
			VirtualMachine: &cloud.AzureIntegrationsVirtualMachineArgs{
				MetricsPollingInterval: pulumi.Int(300),
				ResourceGroups: pulumi.StringArray{
					pulumi.String("resource_groups"),
				},
			},
			VirtualNetworks: &cloud.AzureIntegrationsVirtualNetworksArgs{
				MetricsPollingInterval: pulumi.Int(300),
				ResourceGroups: pulumi.StringArray{
					pulumi.String("resource_groups"),
				},
			},
			Vms: &cloud.AzureIntegrationsVmsArgs{
				MetricsPollingInterval: pulumi.Int(300),
				ResourceGroups: pulumi.StringArray{
					pulumi.String("resource_groups"),
				},
			},
			VpnGateway: &cloud.AzureIntegrationsVpnGatewayArgs{
				MetricsPollingInterval: pulumi.Int(300),
				ResourceGroups: pulumi.StringArray{
					pulumi.String("resource_groups"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var foo = new NewRelic.Cloud.AzureLinkAccount("foo", new()
    {
        AccountId = "The New Relic account ID where you want to link the Azure account",
        ApplicationId = "ID of the application",
        ClientSecret = "Secret value of client's Azure account",
        SubscriptionId = "Subscription ID of Azure",
        TenantId = "Tenant ID of the Azure",
        Name = "Name of the linked account",
    });

    var fooAzureIntegrations = new NewRelic.Cloud.AzureIntegrations("foo", new()
    {
        LinkedAccountId = foo.Id,
        AccountId = "The New Relic account ID",
        ApiManagement = new NewRelic.Cloud.Inputs.AzureIntegrationsApiManagementArgs
        {
            MetricsPollingInterval = 300,
            ResourceGroups = new[]
            {
                "resource_groups",
            },
        },
        AppGateway = new NewRelic.Cloud.Inputs.AzureIntegrationsAppGatewayArgs
        {
            MetricsPollingInterval = 300,
            ResourceGroups = new[]
            {
                "resource_groups",
            },
        },
        AppService = new NewRelic.Cloud.Inputs.AzureIntegrationsAppServiceArgs
        {
            MetricsPollingInterval = 300,
            ResourceGroups = new[]
            {
                "resource_groups",
            },
        },
        Containers = new NewRelic.Cloud.Inputs.AzureIntegrationsContainersArgs
        {
            MetricsPollingInterval = 300,
            ResourceGroups = new[]
            {
                "resource_groups",
            },
        },
        CosmosDb = new NewRelic.Cloud.Inputs.AzureIntegrationsCosmosDbArgs
        {
            MetricsPollingInterval = 300,
            ResourceGroups = new[]
            {
                "resource_groups",
            },
        },
        CostManagement = new NewRelic.Cloud.Inputs.AzureIntegrationsCostManagementArgs
        {
            MetricsPollingInterval = 3600,
            TagKeys = new[]
            {
                "tag_keys",
            },
        },
        DataFactory = new NewRelic.Cloud.Inputs.AzureIntegrationsDataFactoryArgs
        {
            MetricsPollingInterval = 300,
            ResourceGroups = new[]
            {
                "resource_groups",
            },
        },
        EventHub = new NewRelic.Cloud.Inputs.AzureIntegrationsEventHubArgs
        {
            MetricsPollingInterval = 300,
            ResourceGroups = new[]
            {
                "resource_groups",
            },
        },
        ExpressRoute = new NewRelic.Cloud.Inputs.AzureIntegrationsExpressRouteArgs
        {
            MetricsPollingInterval = 300,
            ResourceGroups = new[]
            {
                "resource_groups",
            },
        },
        Firewalls = new NewRelic.Cloud.Inputs.AzureIntegrationsFirewallsArgs
        {
            MetricsPollingInterval = 300,
            ResourceGroups = new[]
            {
                "resource_groups",
            },
        },
        FrontDoor = new NewRelic.Cloud.Inputs.AzureIntegrationsFrontDoorArgs
        {
            MetricsPollingInterval = 300,
            ResourceGroups = new[]
            {
                "resource_groups",
            },
        },
        Functions = new NewRelic.Cloud.Inputs.AzureIntegrationsFunctionsArgs
        {
            MetricsPollingInterval = 300,
            ResourceGroups = new[]
            {
                "resource_groups",
            },
        },
        KeyVault = new NewRelic.Cloud.Inputs.AzureIntegrationsKeyVaultArgs
        {
            MetricsPollingInterval = 300,
            ResourceGroups = new[]
            {
                "resource_groups",
            },
        },
        LoadBalancer = new NewRelic.Cloud.Inputs.AzureIntegrationsLoadBalancerArgs
        {
            MetricsPollingInterval = 300,
            ResourceGroups = new[]
            {
                "resource_groups",
            },
        },
        LogicApps = new NewRelic.Cloud.Inputs.AzureIntegrationsLogicAppsArgs
        {
            MetricsPollingInterval = 300,
            ResourceGroups = new[]
            {
                "resource_groups",
            },
        },
        MachineLearning = new NewRelic.Cloud.Inputs.AzureIntegrationsMachineLearningArgs
        {
            MetricsPollingInterval = 300,
            ResourceGroups = new[]
            {
                "resource_groups",
            },
        },
        MariaDb = new NewRelic.Cloud.Inputs.AzureIntegrationsMariaDbArgs
        {
            MetricsPollingInterval = 3600,
            ResourceGroups = new[]
            {
                "resource_groups",
            },
        },
        Monitor = new NewRelic.Cloud.Inputs.AzureIntegrationsMonitorArgs
        {
            MetricsPollingInterval = 60,
            ResourceGroups = new[]
            {
                "resource_groups",
            },
            IncludeTags = new[]
            {
                "env:production",
            },
            ExcludeTags = new[]
            {
                "env:staging",
                "env:testing",
            },
            Enabled = true,
            ResourceTypes = new[]
            {
                "microsoft.datashare/accounts",
            },
        },
        Mysql = new NewRelic.Cloud.Inputs.AzureIntegrationsMysqlArgs
        {
            MetricsPollingInterval = 3600,
            ResourceGroups = new[]
            {
                "resource_groups",
            },
        },
        MysqlFlexible = new NewRelic.Cloud.Inputs.AzureIntegrationsMysqlFlexibleArgs
        {
            MetricsPollingInterval = 3600,
            ResourceGroups = new[]
            {
                "resource_groups",
            },
        },
        Postgresql = new NewRelic.Cloud.Inputs.AzureIntegrationsPostgresqlArgs
        {
            MetricsPollingInterval = 3600,
            ResourceGroups = new[]
            {
                "resource_groups",
            },
        },
        PostgresqlFlexible = new NewRelic.Cloud.Inputs.AzureIntegrationsPostgresqlFlexibleArgs
        {
            MetricsPollingInterval = 3600,
            ResourceGroups = new[]
            {
                "resource_groups",
            },
        },
        PowerBiDedicated = new NewRelic.Cloud.Inputs.AzureIntegrationsPowerBiDedicatedArgs
        {
            MetricsPollingInterval = 300,
            ResourceGroups = new[]
            {
                "resource_groups",
            },
        },
        RedisCache = new NewRelic.Cloud.Inputs.AzureIntegrationsRedisCacheArgs
        {
            MetricsPollingInterval = 300,
            ResourceGroups = new[]
            {
                "resource_groups",
            },
        },
        ServiceBus = new NewRelic.Cloud.Inputs.AzureIntegrationsServiceBusArgs
        {
            MetricsPollingInterval = 300,
            ResourceGroups = new[]
            {
                "resource_groups",
            },
        },
        Sql = new NewRelic.Cloud.Inputs.AzureIntegrationsSqlArgs
        {
            MetricsPollingInterval = 300,
            ResourceGroups = new[]
            {
                "resource_groups",
            },
        },
        SqlManaged = new NewRelic.Cloud.Inputs.AzureIntegrationsSqlManagedArgs
        {
            MetricsPollingInterval = 300,
            ResourceGroups = new[]
            {
                "resource_groups",
            },
        },
        Storage = new NewRelic.Cloud.Inputs.AzureIntegrationsStorageArgs
        {
            MetricsPollingInterval = 1800,
            ResourceGroups = new[]
            {
                "resource_groups",
            },
        },
        VirtualMachine = new NewRelic.Cloud.Inputs.AzureIntegrationsVirtualMachineArgs
        {
            MetricsPollingInterval = 300,
            ResourceGroups = new[]
            {
                "resource_groups",
            },
        },
        VirtualNetworks = new NewRelic.Cloud.Inputs.AzureIntegrationsVirtualNetworksArgs
        {
            MetricsPollingInterval = 300,
            ResourceGroups = new[]
            {
                "resource_groups",
            },
        },
        Vms = new NewRelic.Cloud.Inputs.AzureIntegrationsVmsArgs
        {
            MetricsPollingInterval = 300,
            ResourceGroups = new[]
            {
                "resource_groups",
            },
        },
        VpnGateway = new NewRelic.Cloud.Inputs.AzureIntegrationsVpnGatewayArgs
        {
            MetricsPollingInterval = 300,
            ResourceGroups = new[]
            {
                "resource_groups",
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.newrelic.cloud.AzureLinkAccount;
import com.pulumi.newrelic.cloud.AzureLinkAccountArgs;
import com.pulumi.newrelic.cloud.AzureIntegrations;
import com.pulumi.newrelic.cloud.AzureIntegrationsArgs;
import com.pulumi.newrelic.cloud.inputs.AzureIntegrationsApiManagementArgs;
import com.pulumi.newrelic.cloud.inputs.AzureIntegrationsAppGatewayArgs;
import com.pulumi.newrelic.cloud.inputs.AzureIntegrationsAppServiceArgs;
import com.pulumi.newrelic.cloud.inputs.AzureIntegrationsContainersArgs;
import com.pulumi.newrelic.cloud.inputs.AzureIntegrationsCosmosDbArgs;
import com.pulumi.newrelic.cloud.inputs.AzureIntegrationsCostManagementArgs;
import com.pulumi.newrelic.cloud.inputs.AzureIntegrationsDataFactoryArgs;
import com.pulumi.newrelic.cloud.inputs.AzureIntegrationsEventHubArgs;
import com.pulumi.newrelic.cloud.inputs.AzureIntegrationsExpressRouteArgs;
import com.pulumi.newrelic.cloud.inputs.AzureIntegrationsFirewallsArgs;
import com.pulumi.newrelic.cloud.inputs.AzureIntegrationsFrontDoorArgs;
import com.pulumi.newrelic.cloud.inputs.AzureIntegrationsFunctionsArgs;
import com.pulumi.newrelic.cloud.inputs.AzureIntegrationsKeyVaultArgs;
import com.pulumi.newrelic.cloud.inputs.AzureIntegrationsLoadBalancerArgs;
import com.pulumi.newrelic.cloud.inputs.AzureIntegrationsLogicAppsArgs;
import com.pulumi.newrelic.cloud.inputs.AzureIntegrationsMachineLearningArgs;
import com.pulumi.newrelic.cloud.inputs.AzureIntegrationsMariaDbArgs;
import com.pulumi.newrelic.cloud.inputs.AzureIntegrationsMonitorArgs;
import com.pulumi.newrelic.cloud.inputs.AzureIntegrationsMysqlArgs;
import com.pulumi.newrelic.cloud.inputs.AzureIntegrationsMysqlFlexibleArgs;
import com.pulumi.newrelic.cloud.inputs.AzureIntegrationsPostgresqlArgs;
import com.pulumi.newrelic.cloud.inputs.AzureIntegrationsPostgresqlFlexibleArgs;
import com.pulumi.newrelic.cloud.inputs.AzureIntegrationsPowerBiDedicatedArgs;
import com.pulumi.newrelic.cloud.inputs.AzureIntegrationsRedisCacheArgs;
import com.pulumi.newrelic.cloud.inputs.AzureIntegrationsServiceBusArgs;
import com.pulumi.newrelic.cloud.inputs.AzureIntegrationsSqlArgs;
import com.pulumi.newrelic.cloud.inputs.AzureIntegrationsSqlManagedArgs;
import com.pulumi.newrelic.cloud.inputs.AzureIntegrationsStorageArgs;
import com.pulumi.newrelic.cloud.inputs.AzureIntegrationsVirtualMachineArgs;
import com.pulumi.newrelic.cloud.inputs.AzureIntegrationsVirtualNetworksArgs;
import com.pulumi.newrelic.cloud.inputs.AzureIntegrationsVmsArgs;
import com.pulumi.newrelic.cloud.inputs.AzureIntegrationsVpnGatewayArgs;
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 foo = new AzureLinkAccount("foo", AzureLinkAccountArgs.builder()
            .accountId("The New Relic account ID where you want to link the Azure account")
            .applicationId("ID of the application")
            .clientSecret("Secret value of client's Azure account")
            .subscriptionId("Subscription ID of Azure")
            .tenantId("Tenant ID of the Azure")
            .name("Name of the linked account")
            .build());

        var fooAzureIntegrations = new AzureIntegrations("fooAzureIntegrations", AzureIntegrationsArgs.builder()
            .linkedAccountId(foo.id())
            .accountId("The New Relic account ID")
            .apiManagement(AzureIntegrationsApiManagementArgs.builder()
                .metricsPollingInterval(300)
                .resourceGroups("resource_groups")
                .build())
            .appGateway(AzureIntegrationsAppGatewayArgs.builder()
                .metricsPollingInterval(300)
                .resourceGroups("resource_groups")
                .build())
            .appService(AzureIntegrationsAppServiceArgs.builder()
                .metricsPollingInterval(300)
                .resourceGroups("resource_groups")
                .build())
            .containers(AzureIntegrationsContainersArgs.builder()
                .metricsPollingInterval(300)
                .resourceGroups("resource_groups")
                .build())
            .cosmosDb(AzureIntegrationsCosmosDbArgs.builder()
                .metricsPollingInterval(300)
                .resourceGroups("resource_groups")
                .build())
            .costManagement(AzureIntegrationsCostManagementArgs.builder()
                .metricsPollingInterval(3600)
                .tagKeys("tag_keys")
                .build())
            .dataFactory(AzureIntegrationsDataFactoryArgs.builder()
                .metricsPollingInterval(300)
                .resourceGroups("resource_groups")
                .build())
            .eventHub(AzureIntegrationsEventHubArgs.builder()
                .metricsPollingInterval(300)
                .resourceGroups("resource_groups")
                .build())
            .expressRoute(AzureIntegrationsExpressRouteArgs.builder()
                .metricsPollingInterval(300)
                .resourceGroups("resource_groups")
                .build())
            .firewalls(AzureIntegrationsFirewallsArgs.builder()
                .metricsPollingInterval(300)
                .resourceGroups("resource_groups")
                .build())
            .frontDoor(AzureIntegrationsFrontDoorArgs.builder()
                .metricsPollingInterval(300)
                .resourceGroups("resource_groups")
                .build())
            .functions(AzureIntegrationsFunctionsArgs.builder()
                .metricsPollingInterval(300)
                .resourceGroups("resource_groups")
                .build())
            .keyVault(AzureIntegrationsKeyVaultArgs.builder()
                .metricsPollingInterval(300)
                .resourceGroups("resource_groups")
                .build())
            .loadBalancer(AzureIntegrationsLoadBalancerArgs.builder()
                .metricsPollingInterval(300)
                .resourceGroups("resource_groups")
                .build())
            .logicApps(AzureIntegrationsLogicAppsArgs.builder()
                .metricsPollingInterval(300)
                .resourceGroups("resource_groups")
                .build())
            .machineLearning(AzureIntegrationsMachineLearningArgs.builder()
                .metricsPollingInterval(300)
                .resourceGroups("resource_groups")
                .build())
            .mariaDb(AzureIntegrationsMariaDbArgs.builder()
                .metricsPollingInterval(3600)
                .resourceGroups("resource_groups")
                .build())
            .monitor(AzureIntegrationsMonitorArgs.builder()
                .metricsPollingInterval(60)
                .resourceGroups("resource_groups")
                .includeTags("env:production")
                .excludeTags(                
                    "env:staging",
                    "env:testing")
                .enabled(true)
                .resourceTypes("microsoft.datashare/accounts")
                .build())
            .mysql(AzureIntegrationsMysqlArgs.builder()
                .metricsPollingInterval(3600)
                .resourceGroups("resource_groups")
                .build())
            .mysqlFlexible(AzureIntegrationsMysqlFlexibleArgs.builder()
                .metricsPollingInterval(3600)
                .resourceGroups("resource_groups")
                .build())
            .postgresql(AzureIntegrationsPostgresqlArgs.builder()
                .metricsPollingInterval(3600)
                .resourceGroups("resource_groups")
                .build())
            .postgresqlFlexible(AzureIntegrationsPostgresqlFlexibleArgs.builder()
                .metricsPollingInterval(3600)
                .resourceGroups("resource_groups")
                .build())
            .powerBiDedicated(AzureIntegrationsPowerBiDedicatedArgs.builder()
                .metricsPollingInterval(300)
                .resourceGroups("resource_groups")
                .build())
            .redisCache(AzureIntegrationsRedisCacheArgs.builder()
                .metricsPollingInterval(300)
                .resourceGroups("resource_groups")
                .build())
            .serviceBus(AzureIntegrationsServiceBusArgs.builder()
                .metricsPollingInterval(300)
                .resourceGroups("resource_groups")
                .build())
            .sql(AzureIntegrationsSqlArgs.builder()
                .metricsPollingInterval(300)
                .resourceGroups("resource_groups")
                .build())
            .sqlManaged(AzureIntegrationsSqlManagedArgs.builder()
                .metricsPollingInterval(300)
                .resourceGroups("resource_groups")
                .build())
            .storage(AzureIntegrationsStorageArgs.builder()
                .metricsPollingInterval(1800)
                .resourceGroups("resource_groups")
                .build())
            .virtualMachine(AzureIntegrationsVirtualMachineArgs.builder()
                .metricsPollingInterval(300)
                .resourceGroups("resource_groups")
                .build())
            .virtualNetworks(AzureIntegrationsVirtualNetworksArgs.builder()
                .metricsPollingInterval(300)
                .resourceGroups("resource_groups")
                .build())
            .vms(AzureIntegrationsVmsArgs.builder()
                .metricsPollingInterval(300)
                .resourceGroups("resource_groups")
                .build())
            .vpnGateway(AzureIntegrationsVpnGatewayArgs.builder()
                .metricsPollingInterval(300)
                .resourceGroups("resource_groups")
                .build())
            .build());

    }
}

resources:
  foo:
    type: newrelic:cloud:AzureLinkAccount
    properties:
      accountId: The New Relic account ID where you want to link the Azure account
      applicationId: ID of the application
      clientSecret: Secret value of client's Azure account
      subscriptionId: Subscription ID of Azure
      tenantId: Tenant ID of the Azure
      name: Name of the linked account
  fooAzureIntegrations:
    type: newrelic:cloud:AzureIntegrations
    name: foo
    properties:
      linkedAccountId: ${foo.id}
      accountId: The New Relic account ID
      apiManagement:
        metricsPollingInterval: 300
        resourceGroups:
          - resource_groups
      appGateway:
        metricsPollingInterval: 300
        resourceGroups:
          - resource_groups
      appService:
        metricsPollingInterval: 300
        resourceGroups:
          - resource_groups
      containers:
        metricsPollingInterval: 300
        resourceGroups:
          - resource_groups
      cosmosDb:
        metricsPollingInterval: 300
        resourceGroups:
          - resource_groups
      costManagement:
        metricsPollingInterval: 3600
        tagKeys:
          - tag_keys
      dataFactory:
        metricsPollingInterval: 300
        resourceGroups:
          - resource_groups
      eventHub:
        metricsPollingInterval: 300
        resourceGroups:
          - resource_groups
      expressRoute:
        metricsPollingInterval: 300
        resourceGroups:
          - resource_groups
      firewalls:
        metricsPollingInterval: 300
        resourceGroups:
          - resource_groups
      frontDoor:
        metricsPollingInterval: 300
        resourceGroups:
          - resource_groups
      functions:
        metricsPollingInterval: 300
        resourceGroups:
          - resource_groups
      keyVault:
        metricsPollingInterval: 300
        resourceGroups:
          - resource_groups
      loadBalancer:
        metricsPollingInterval: 300
        resourceGroups:
          - resource_groups
      logicApps:
        metricsPollingInterval: 300
        resourceGroups:
          - resource_groups
      machineLearning:
        metricsPollingInterval: 300
        resourceGroups:
          - resource_groups
      mariaDb:
        metricsPollingInterval: 3600
        resourceGroups:
          - resource_groups
      monitor:
        metricsPollingInterval: 60
        resourceGroups:
          - resource_groups
        includeTags:
          - env:production
        excludeTags:
          - env:staging
          - env:testing
        enabled: true
        resourceTypes:
          - microsoft.datashare/accounts
      mysql:
        metricsPollingInterval: 3600
        resourceGroups:
          - resource_groups
      mysqlFlexible:
        metricsPollingInterval: 3600
        resourceGroups:
          - resource_groups
      postgresql:
        metricsPollingInterval: 3600
        resourceGroups:
          - resource_groups
      postgresqlFlexible:
        metricsPollingInterval: 3600
        resourceGroups:
          - resource_groups
      powerBiDedicated:
        metricsPollingInterval: 300
        resourceGroups:
          - resource_groups
      redisCache:
        metricsPollingInterval: 300
        resourceGroups:
          - resource_groups
      serviceBus:
        metricsPollingInterval: 300
        resourceGroups:
          - resource_groups
      sql:
        metricsPollingInterval: 300
        resourceGroups:
          - resource_groups
      sqlManaged:
        metricsPollingInterval: 300
        resourceGroups:
          - resource_groups
      storage:
        metricsPollingInterval: 1800
        resourceGroups:
          - resource_groups
      virtualMachine:
        metricsPollingInterval: 300
        resourceGroups:
          - resource_groups
      virtualNetworks:
        metricsPollingInterval: 300
        resourceGroups:
          - resource_groups
      vms:
        metricsPollingInterval: 300
        resourceGroups:
          - resource_groups
      vpnGateway:
        metricsPollingInterval: 300
        resourceGroups:
          - resource_groups

var azureIntegrationsResource = new NewRelic.Cloud.AzureIntegrations("azureIntegrationsResource", new()
{
    LinkedAccountId = "string",
    LogicApps = new NewRelic.Cloud.Inputs.AzureIntegrationsLogicAppsArgs
    {
        MetricsPollingInterval = 0,
        ResourceGroups = new[]
        {
            "string",
        },
    },
    EventHub = new NewRelic.Cloud.Inputs.AzureIntegrationsEventHubArgs
    {
        MetricsPollingInterval = 0,
        ResourceGroups = new[]
        {
            "string",
        },
    },
    AppService = new NewRelic.Cloud.Inputs.AzureIntegrationsAppServiceArgs
    {
        MetricsPollingInterval = 0,
        ResourceGroups = new[]
        {
            "string",
        },
    },
    MachineLearning = new NewRelic.Cloud.Inputs.AzureIntegrationsMachineLearningArgs
    {
        MetricsPollingInterval = 0,
        ResourceGroups = new[]
        {
            "string",
        },
    },
    CosmosDb = new NewRelic.Cloud.Inputs.AzureIntegrationsCosmosDbArgs
    {
        MetricsPollingInterval = 0,
        ResourceGroups = new[]
        {
            "string",
        },
    },
    CostManagement = new NewRelic.Cloud.Inputs.AzureIntegrationsCostManagementArgs
    {
        MetricsPollingInterval = 0,
        TagKeys = new[]
        {
            "string",
        },
    },
    DataFactory = new NewRelic.Cloud.Inputs.AzureIntegrationsDataFactoryArgs
    {
        MetricsPollingInterval = 0,
        ResourceGroups = new[]
        {
            "string",
        },
    },
    MariaDb = new NewRelic.Cloud.Inputs.AzureIntegrationsMariaDbArgs
    {
        MetricsPollingInterval = 0,
        ResourceGroups = new[]
        {
            "string",
        },
    },
    ExpressRoute = new NewRelic.Cloud.Inputs.AzureIntegrationsExpressRouteArgs
    {
        MetricsPollingInterval = 0,
        ResourceGroups = new[]
        {
            "string",
        },
    },
    Firewalls = new NewRelic.Cloud.Inputs.AzureIntegrationsFirewallsArgs
    {
        MetricsPollingInterval = 0,
        ResourceGroups = new[]
        {
            "string",
        },
    },
    FrontDoor = new NewRelic.Cloud.Inputs.AzureIntegrationsFrontDoorArgs
    {
        MetricsPollingInterval = 0,
        ResourceGroups = new[]
        {
            "string",
        },
    },
    Functions = new NewRelic.Cloud.Inputs.AzureIntegrationsFunctionsArgs
    {
        MetricsPollingInterval = 0,
        ResourceGroups = new[]
        {
            "string",
        },
    },
    KeyVault = new NewRelic.Cloud.Inputs.AzureIntegrationsKeyVaultArgs
    {
        MetricsPollingInterval = 0,
        ResourceGroups = new[]
        {
            "string",
        },
    },
    Monitor = new NewRelic.Cloud.Inputs.AzureIntegrationsMonitorArgs
    {
        Enabled = false,
        ExcludeTags = new[]
        {
            "string",
        },
        IncludeTags = new[]
        {
            "string",
        },
        MetricsPollingInterval = 0,
        ResourceGroups = new[]
        {
            "string",
        },
        ResourceTypes = new[]
        {
            "string",
        },
    },
    LoadBalancer = new NewRelic.Cloud.Inputs.AzureIntegrationsLoadBalancerArgs
    {
        MetricsPollingInterval = 0,
        ResourceGroups = new[]
        {
            "string",
        },
    },
    AccountId = "string",
    Containers = new NewRelic.Cloud.Inputs.AzureIntegrationsContainersArgs
    {
        MetricsPollingInterval = 0,
        ResourceGroups = new[]
        {
            "string",
        },
    },
    AppGateway = new NewRelic.Cloud.Inputs.AzureIntegrationsAppGatewayArgs
    {
        MetricsPollingInterval = 0,
        ResourceGroups = new[]
        {
            "string",
        },
    },
    ApiManagement = new NewRelic.Cloud.Inputs.AzureIntegrationsApiManagementArgs
    {
        MetricsPollingInterval = 0,
        ResourceGroups = new[]
        {
            "string",
        },
    },
    Mysql = new NewRelic.Cloud.Inputs.AzureIntegrationsMysqlArgs
    {
        MetricsPollingInterval = 0,
        ResourceGroups = new[]
        {
            "string",
        },
    },
    MysqlFlexible = new NewRelic.Cloud.Inputs.AzureIntegrationsMysqlFlexibleArgs
    {
        MetricsPollingInterval = 0,
        ResourceGroups = new[]
        {
            "string",
        },
    },
    Postgresql = new NewRelic.Cloud.Inputs.AzureIntegrationsPostgresqlArgs
    {
        MetricsPollingInterval = 0,
        ResourceGroups = new[]
        {
            "string",
        },
    },
    PostgresqlFlexible = new NewRelic.Cloud.Inputs.AzureIntegrationsPostgresqlFlexibleArgs
    {
        MetricsPollingInterval = 0,
        ResourceGroups = new[]
        {
            "string",
        },
    },
    PowerBiDedicated = new NewRelic.Cloud.Inputs.AzureIntegrationsPowerBiDedicatedArgs
    {
        MetricsPollingInterval = 0,
        ResourceGroups = new[]
        {
            "string",
        },
    },
    RedisCache = new NewRelic.Cloud.Inputs.AzureIntegrationsRedisCacheArgs
    {
        MetricsPollingInterval = 0,
        ResourceGroups = new[]
        {
            "string",
        },
    },
    ServiceBus = new NewRelic.Cloud.Inputs.AzureIntegrationsServiceBusArgs
    {
        MetricsPollingInterval = 0,
        ResourceGroups = new[]
        {
            "string",
        },
    },
    Sql = new NewRelic.Cloud.Inputs.AzureIntegrationsSqlArgs
    {
        MetricsPollingInterval = 0,
        ResourceGroups = new[]
        {
            "string",
        },
    },
    SqlManaged = new NewRelic.Cloud.Inputs.AzureIntegrationsSqlManagedArgs
    {
        MetricsPollingInterval = 0,
        ResourceGroups = new[]
        {
            "string",
        },
    },
    Storage = new NewRelic.Cloud.Inputs.AzureIntegrationsStorageArgs
    {
        MetricsPollingInterval = 0,
        ResourceGroups = new[]
        {
            "string",
        },
    },
    VirtualMachine = new NewRelic.Cloud.Inputs.AzureIntegrationsVirtualMachineArgs
    {
        MetricsPollingInterval = 0,
        ResourceGroups = new[]
        {
            "string",
        },
    },
    VirtualNetworks = new NewRelic.Cloud.Inputs.AzureIntegrationsVirtualNetworksArgs
    {
        MetricsPollingInterval = 0,
        ResourceGroups = new[]
        {
            "string",
        },
    },
    Vms = new NewRelic.Cloud.Inputs.AzureIntegrationsVmsArgs
    {
        MetricsPollingInterval = 0,
        ResourceGroups = new[]
        {
            "string",
        },
    },
    VpnGateway = new NewRelic.Cloud.Inputs.AzureIntegrationsVpnGatewayArgs
    {
        MetricsPollingInterval = 0,
        ResourceGroups = new[]
        {
            "string",
        },
    },
});