newrelic.cloud.AzureIntegrations

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

return await Deployment.RunAsync(() => 
{
    var fooAzureLinkAccount = new NewRelic.Cloud.AzureLinkAccount("fooAzureLinkAccount", 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",
    });

    var fooAzureIntegrations = new NewRelic.Cloud.AzureIntegrations("fooAzureIntegrations", new()
    {
        LinkedAccountId = fooAzureLinkAccount.Id,
        AccountId = "The New Relic account ID",
        ApiManagement = new NewRelic.Cloud.Inputs.AzureIntegrationsApiManagementArgs
        {
            MetricsPollingInterval = 1200,
            ResourceGroups = new[]
            {
                "resource_groups",
            },
        },
        AppGateway = new NewRelic.Cloud.Inputs.AzureIntegrationsAppGatewayArgs
        {
            MetricsPollingInterval = 1200,
            ResourceGroups = new[]
            {
                "resource_groups",
            },
        },
        AppService = new NewRelic.Cloud.Inputs.AzureIntegrationsAppServiceArgs
        {
            MetricsPollingInterval = 1200,
            ResourceGroups = new[]
            {
                "resource_groups",
            },
        },
        Containers = new NewRelic.Cloud.Inputs.AzureIntegrationsContainersArgs
        {
            MetricsPollingInterval = 1200,
            ResourceGroups = new[]
            {
                "resource_groups",
            },
        },
        CosmosDb = new NewRelic.Cloud.Inputs.AzureIntegrationsCosmosDbArgs
        {
            MetricsPollingInterval = 1200,
            ResourceGroups = new[]
            {
                "resource_groups",
            },
        },
        CostManagement = new NewRelic.Cloud.Inputs.AzureIntegrationsCostManagementArgs
        {
            MetricsPollingInterval = 3600,
            TagKeys = new[]
            {
                "tag_keys",
            },
        },
        DataFactory = new NewRelic.Cloud.Inputs.AzureIntegrationsDataFactoryArgs
        {
            MetricsPollingInterval = 1200,
            ResourceGroups = new[]
            {
                "resource_groups",
            },
        },
        EventHub = new NewRelic.Cloud.Inputs.AzureIntegrationsEventHubArgs
        {
            MetricsPollingInterval = 1200,
            ResourceGroups = new[]
            {
                "resource_groups",
            },
        },
        ExpressRoute = new NewRelic.Cloud.Inputs.AzureIntegrationsExpressRouteArgs
        {
            MetricsPollingInterval = 1200,
            ResourceGroups = new[]
            {
                "resource_groups",
            },
        },
        Firewalls = new NewRelic.Cloud.Inputs.AzureIntegrationsFirewallsArgs
        {
            MetricsPollingInterval = 1200,
            ResourceGroups = new[]
            {
                "resource_groups",
            },
        },
        FrontDoor = new NewRelic.Cloud.Inputs.AzureIntegrationsFrontDoorArgs
        {
            MetricsPollingInterval = 1200,
            ResourceGroups = new[]
            {
                "resource_groups",
            },
        },
        Functions = new NewRelic.Cloud.Inputs.AzureIntegrationsFunctionsArgs
        {
            MetricsPollingInterval = 1200,
            ResourceGroups = new[]
            {
                "resource_groups",
            },
        },
        KeyVault = new NewRelic.Cloud.Inputs.AzureIntegrationsKeyVaultArgs
        {
            MetricsPollingInterval = 1200,
            ResourceGroups = new[]
            {
                "resource_groups",
            },
        },
        LoadBalancer = new NewRelic.Cloud.Inputs.AzureIntegrationsLoadBalancerArgs
        {
            MetricsPollingInterval = 1200,
            ResourceGroups = new[]
            {
                "resource_groups",
            },
        },
        LogicApps = new NewRelic.Cloud.Inputs.AzureIntegrationsLogicAppsArgs
        {
            MetricsPollingInterval = 1200,
            ResourceGroups = new[]
            {
                "resource_groups",
            },
        },
        MachineLearning = new NewRelic.Cloud.Inputs.AzureIntegrationsMachineLearningArgs
        {
            MetricsPollingInterval = 1200,
            ResourceGroups = new[]
            {
                "resource_groups",
            },
        },
        MariaDb = new NewRelic.Cloud.Inputs.AzureIntegrationsMariaDbArgs
        {
            MetricsPollingInterval = 1200,
            ResourceGroups = new[]
            {
                "resource_groups",
            },
        },
        Monitor = new NewRelic.Cloud.Inputs.AzureIntegrationsMonitorArgs
        {
            MetricsPollingInterval = 1200,
            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 = 1200,
            ResourceGroups = new[]
            {
                "resource_groups",
            },
        },
        MysqlFlexible = new NewRelic.Cloud.Inputs.AzureIntegrationsMysqlFlexibleArgs
        {
            MetricsPollingInterval = 1200,
            ResourceGroups = new[]
            {
                "resource_groups",
            },
        },
        Postgresql = new NewRelic.Cloud.Inputs.AzureIntegrationsPostgresqlArgs
        {
            MetricsPollingInterval = 1200,
            ResourceGroups = new[]
            {
                "resource_groups",
            },
        },
        PostgresqlFlexible = new NewRelic.Cloud.Inputs.AzureIntegrationsPostgresqlFlexibleArgs
        {
            MetricsPollingInterval = 1200,
            ResourceGroups = new[]
            {
                "resource_groups",
            },
        },
        PowerBiDedicated = new NewRelic.Cloud.Inputs.AzureIntegrationsPowerBiDedicatedArgs
        {
            MetricsPollingInterval = 1200,
            ResourceGroups = new[]
            {
                "resource_groups",
            },
        },
        RedisCache = new NewRelic.Cloud.Inputs.AzureIntegrationsRedisCacheArgs
        {
            MetricsPollingInterval = 1200,
            ResourceGroups = new[]
            {
                "resource_groups",
            },
        },
        ServiceBus = new NewRelic.Cloud.Inputs.AzureIntegrationsServiceBusArgs
        {
            MetricsPollingInterval = 1200,
            ResourceGroups = new[]
            {
                "resource_groups",
            },
        },
        Sql = new NewRelic.Cloud.Inputs.AzureIntegrationsSqlArgs
        {
            MetricsPollingInterval = 1200,
            ResourceGroups = new[]
            {
                "resource_groups",
            },
        },
        SqlManaged = new NewRelic.Cloud.Inputs.AzureIntegrationsSqlManagedArgs
        {
            MetricsPollingInterval = 1200,
            ResourceGroups = new[]
            {
                "resource_groups",
            },
        },
        Storage = new NewRelic.Cloud.Inputs.AzureIntegrationsStorageArgs
        {
            MetricsPollingInterval = 1200,
            ResourceGroups = new[]
            {
                "resource_groups",
            },
        },
        VirtualMachine = new NewRelic.Cloud.Inputs.AzureIntegrationsVirtualMachineArgs
        {
            MetricsPollingInterval = 1200,
            ResourceGroups = new[]
            {
                "resource_groups",
            },
        },
        VirtualNetworks = new NewRelic.Cloud.Inputs.AzureIntegrationsVirtualNetworksArgs
        {
            MetricsPollingInterval = 1200,
            ResourceGroups = new[]
            {
                "resource_groups",
            },
        },
        Vms = new NewRelic.Cloud.Inputs.AzureIntegrationsVmsArgs
        {
            MetricsPollingInterval = 1200,
            ResourceGroups = new[]
            {
                "resource_groups",
            },
        },
        VpnGateway = new NewRelic.Cloud.Inputs.AzureIntegrationsVpnGatewayArgs
        {
            MetricsPollingInterval = 1200,
            ResourceGroups = new[]
            {
                "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 {
		fooAzureLinkAccount, err := cloud.NewAzureLinkAccount(ctx, "fooAzureLinkAccount", &cloud.AzureLinkAccountArgs{
			AccountId:      pulumi.Int("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"),
		})
		if err != nil {
			return err
		}
		_, err = cloud.NewAzureIntegrations(ctx, "fooAzureIntegrations", &cloud.AzureIntegrationsArgs{
			LinkedAccountId: fooAzureLinkAccount.ID(),
			AccountId:       pulumi.Int("The New Relic account ID"),
			ApiManagement: &cloud.AzureIntegrationsApiManagementArgs{
				MetricsPollingInterval: pulumi.Int(1200),
				ResourceGroups: pulumi.StringArray{
					pulumi.String("resource_groups"),
				},
			},
			AppGateway: &cloud.AzureIntegrationsAppGatewayArgs{
				MetricsPollingInterval: pulumi.Int(1200),
				ResourceGroups: pulumi.StringArray{
					pulumi.String("resource_groups"),
				},
			},
			AppService: &cloud.AzureIntegrationsAppServiceArgs{
				MetricsPollingInterval: pulumi.Int(1200),
				ResourceGroups: pulumi.StringArray{
					pulumi.String("resource_groups"),
				},
			},
			Containers: &cloud.AzureIntegrationsContainersArgs{
				MetricsPollingInterval: pulumi.Int(1200),
				ResourceGroups: pulumi.StringArray{
					pulumi.String("resource_groups"),
				},
			},
			CosmosDb: &cloud.AzureIntegrationsCosmosDbArgs{
				MetricsPollingInterval: pulumi.Int(1200),
				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(1200),
				ResourceGroups: pulumi.StringArray{
					pulumi.String("resource_groups"),
				},
			},
			EventHub: &cloud.AzureIntegrationsEventHubArgs{
				MetricsPollingInterval: pulumi.Int(1200),
				ResourceGroups: pulumi.StringArray{
					pulumi.String("resource_groups"),
				},
			},
			ExpressRoute: &cloud.AzureIntegrationsExpressRouteArgs{
				MetricsPollingInterval: pulumi.Int(1200),
				ResourceGroups: pulumi.StringArray{
					pulumi.String("resource_groups"),
				},
			},
			Firewalls: &cloud.AzureIntegrationsFirewallsArgs{
				MetricsPollingInterval: pulumi.Int(1200),
				ResourceGroups: pulumi.StringArray{
					pulumi.String("resource_groups"),
				},
			},
			FrontDoor: &cloud.AzureIntegrationsFrontDoorArgs{
				MetricsPollingInterval: pulumi.Int(1200),
				ResourceGroups: pulumi.StringArray{
					pulumi.String("resource_groups"),
				},
			},
			Functions: &cloud.AzureIntegrationsFunctionsArgs{
				MetricsPollingInterval: pulumi.Int(1200),
				ResourceGroups: pulumi.StringArray{
					pulumi.String("resource_groups"),
				},
			},
			KeyVault: &cloud.AzureIntegrationsKeyVaultArgs{
				MetricsPollingInterval: pulumi.Int(1200),
				ResourceGroups: pulumi.StringArray{
					pulumi.String("resource_groups"),
				},
			},
			LoadBalancer: &cloud.AzureIntegrationsLoadBalancerArgs{
				MetricsPollingInterval: pulumi.Int(1200),
				ResourceGroups: pulumi.StringArray{
					pulumi.String("resource_groups"),
				},
			},
			LogicApps: &cloud.AzureIntegrationsLogicAppsArgs{
				MetricsPollingInterval: pulumi.Int(1200),
				ResourceGroups: pulumi.StringArray{
					pulumi.String("resource_groups"),
				},
			},
			MachineLearning: &cloud.AzureIntegrationsMachineLearningArgs{
				MetricsPollingInterval: pulumi.Int(1200),
				ResourceGroups: pulumi.StringArray{
					pulumi.String("resource_groups"),
				},
			},
			MariaDb: &cloud.AzureIntegrationsMariaDbArgs{
				MetricsPollingInterval: pulumi.Int(1200),
				ResourceGroups: pulumi.StringArray{
					pulumi.String("resource_groups"),
				},
			},
			Monitor: &cloud.AzureIntegrationsMonitorArgs{
				MetricsPollingInterval: pulumi.Int(1200),
				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(1200),
				ResourceGroups: pulumi.StringArray{
					pulumi.String("resource_groups"),
				},
			},
			MysqlFlexible: &cloud.AzureIntegrationsMysqlFlexibleArgs{
				MetricsPollingInterval: pulumi.Int(1200),
				ResourceGroups: pulumi.StringArray{
					pulumi.String("resource_groups"),
				},
			},
			Postgresql: &cloud.AzureIntegrationsPostgresqlArgs{
				MetricsPollingInterval: pulumi.Int(1200),
				ResourceGroups: pulumi.StringArray{
					pulumi.String("resource_groups"),
				},
			},
			PostgresqlFlexible: &cloud.AzureIntegrationsPostgresqlFlexibleArgs{
				MetricsPollingInterval: pulumi.Int(1200),
				ResourceGroups: pulumi.StringArray{
					pulumi.String("resource_groups"),
				},
			},
			PowerBiDedicated: &cloud.AzureIntegrationsPowerBiDedicatedArgs{
				MetricsPollingInterval: pulumi.Int(1200),
				ResourceGroups: pulumi.StringArray{
					pulumi.String("resource_groups"),
				},
			},
			RedisCache: &cloud.AzureIntegrationsRedisCacheArgs{
				MetricsPollingInterval: pulumi.Int(1200),
				ResourceGroups: pulumi.StringArray{
					pulumi.String("resource_groups"),
				},
			},
			ServiceBus: &cloud.AzureIntegrationsServiceBusArgs{
				MetricsPollingInterval: pulumi.Int(1200),
				ResourceGroups: pulumi.StringArray{
					pulumi.String("resource_groups"),
				},
			},
			Sql: &cloud.AzureIntegrationsSqlArgs{
				MetricsPollingInterval: pulumi.Int(1200),
				ResourceGroups: pulumi.StringArray{
					pulumi.String("resource_groups"),
				},
			},
			SqlManaged: &cloud.AzureIntegrationsSqlManagedArgs{
				MetricsPollingInterval: pulumi.Int(1200),
				ResourceGroups: pulumi.StringArray{
					pulumi.String("resource_groups"),
				},
			},
			Storage: &cloud.AzureIntegrationsStorageArgs{
				MetricsPollingInterval: pulumi.Int(1200),
				ResourceGroups: pulumi.StringArray{
					pulumi.String("resource_groups"),
				},
			},
			VirtualMachine: &cloud.AzureIntegrationsVirtualMachineArgs{
				MetricsPollingInterval: pulumi.Int(1200),
				ResourceGroups: pulumi.StringArray{
					pulumi.String("resource_groups"),
				},
			},
			VirtualNetworks: &cloud.AzureIntegrationsVirtualNetworksArgs{
				MetricsPollingInterval: pulumi.Int(1200),
				ResourceGroups: pulumi.StringArray{
					pulumi.String("resource_groups"),
				},
			},
			Vms: &cloud.AzureIntegrationsVmsArgs{
				MetricsPollingInterval: pulumi.Int(1200),
				ResourceGroups: pulumi.StringArray{
					pulumi.String("resource_groups"),
				},
			},
			VpnGateway: &cloud.AzureIntegrationsVpnGatewayArgs{
				MetricsPollingInterval: pulumi.Int(1200),
				ResourceGroups: pulumi.StringArray{
					pulumi.String("resource_groups"),
				},
			},
		})
		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.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 fooAzureLinkAccount = new AzureLinkAccount("fooAzureLinkAccount", 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")
            .build());

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

    }
}

import pulumi
import pulumi_newrelic as newrelic

foo_azure_link_account = newrelic.cloud.AzureLinkAccount("fooAzureLinkAccount",
    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")
foo_azure_integrations = newrelic.cloud.AzureIntegrations("fooAzureIntegrations",
    linked_account_id=foo_azure_link_account.id,
    account_id="The New Relic account ID",
    api_management=newrelic.cloud.AzureIntegrationsApiManagementArgs(
        metrics_polling_interval=1200,
        resource_groups=["resource_groups"],
    ),
    app_gateway=newrelic.cloud.AzureIntegrationsAppGatewayArgs(
        metrics_polling_interval=1200,
        resource_groups=["resource_groups"],
    ),
    app_service=newrelic.cloud.AzureIntegrationsAppServiceArgs(
        metrics_polling_interval=1200,
        resource_groups=["resource_groups"],
    ),
    containers=newrelic.cloud.AzureIntegrationsContainersArgs(
        metrics_polling_interval=1200,
        resource_groups=["resource_groups"],
    ),
    cosmos_db=newrelic.cloud.AzureIntegrationsCosmosDbArgs(
        metrics_polling_interval=1200,
        resource_groups=["resource_groups"],
    ),
    cost_management=newrelic.cloud.AzureIntegrationsCostManagementArgs(
        metrics_polling_interval=3600,
        tag_keys=["tag_keys"],
    ),
    data_factory=newrelic.cloud.AzureIntegrationsDataFactoryArgs(
        metrics_polling_interval=1200,
        resource_groups=["resource_groups"],
    ),
    event_hub=newrelic.cloud.AzureIntegrationsEventHubArgs(
        metrics_polling_interval=1200,
        resource_groups=["resource_groups"],
    ),
    express_route=newrelic.cloud.AzureIntegrationsExpressRouteArgs(
        metrics_polling_interval=1200,
        resource_groups=["resource_groups"],
    ),
    firewalls=newrelic.cloud.AzureIntegrationsFirewallsArgs(
        metrics_polling_interval=1200,
        resource_groups=["resource_groups"],
    ),
    front_door=newrelic.cloud.AzureIntegrationsFrontDoorArgs(
        metrics_polling_interval=1200,
        resource_groups=["resource_groups"],
    ),
    functions=newrelic.cloud.AzureIntegrationsFunctionsArgs(
        metrics_polling_interval=1200,
        resource_groups=["resource_groups"],
    ),
    key_vault=newrelic.cloud.AzureIntegrationsKeyVaultArgs(
        metrics_polling_interval=1200,
        resource_groups=["resource_groups"],
    ),
    load_balancer=newrelic.cloud.AzureIntegrationsLoadBalancerArgs(
        metrics_polling_interval=1200,
        resource_groups=["resource_groups"],
    ),
    logic_apps=newrelic.cloud.AzureIntegrationsLogicAppsArgs(
        metrics_polling_interval=1200,
        resource_groups=["resource_groups"],
    ),
    machine_learning=newrelic.cloud.AzureIntegrationsMachineLearningArgs(
        metrics_polling_interval=1200,
        resource_groups=["resource_groups"],
    ),
    maria_db=newrelic.cloud.AzureIntegrationsMariaDbArgs(
        metrics_polling_interval=1200,
        resource_groups=["resource_groups"],
    ),
    monitor=newrelic.cloud.AzureIntegrationsMonitorArgs(
        metrics_polling_interval=1200,
        resource_groups=["resource_groups"],
        include_tags=["env:production"],
        exclude_tags=[
            "env:staging",
            "env:testing",
        ],
        enabled=True,
        resource_types=["microsoft.datashare/accounts"],
    ),
    mysql=newrelic.cloud.AzureIntegrationsMysqlArgs(
        metrics_polling_interval=1200,
        resource_groups=["resource_groups"],
    ),
    mysql_flexible=newrelic.cloud.AzureIntegrationsMysqlFlexibleArgs(
        metrics_polling_interval=1200,
        resource_groups=["resource_groups"],
    ),
    postgresql=newrelic.cloud.AzureIntegrationsPostgresqlArgs(
        metrics_polling_interval=1200,
        resource_groups=["resource_groups"],
    ),
    postgresql_flexible=newrelic.cloud.AzureIntegrationsPostgresqlFlexibleArgs(
        metrics_polling_interval=1200,
        resource_groups=["resource_groups"],
    ),
    power_bi_dedicated=newrelic.cloud.AzureIntegrationsPowerBiDedicatedArgs(
        metrics_polling_interval=1200,
        resource_groups=["resource_groups"],
    ),
    redis_cache=newrelic.cloud.AzureIntegrationsRedisCacheArgs(
        metrics_polling_interval=1200,
        resource_groups=["resource_groups"],
    ),
    service_bus=newrelic.cloud.AzureIntegrationsServiceBusArgs(
        metrics_polling_interval=1200,
        resource_groups=["resource_groups"],
    ),
    sql=newrelic.cloud.AzureIntegrationsSqlArgs(
        metrics_polling_interval=1200,
        resource_groups=["resource_groups"],
    ),
    sql_managed=newrelic.cloud.AzureIntegrationsSqlManagedArgs(
        metrics_polling_interval=1200,
        resource_groups=["resource_groups"],
    ),
    storage=newrelic.cloud.AzureIntegrationsStorageArgs(
        metrics_polling_interval=1200,
        resource_groups=["resource_groups"],
    ),
    virtual_machine=newrelic.cloud.AzureIntegrationsVirtualMachineArgs(
        metrics_polling_interval=1200,
        resource_groups=["resource_groups"],
    ),
    virtual_networks=newrelic.cloud.AzureIntegrationsVirtualNetworksArgs(
        metrics_polling_interval=1200,
        resource_groups=["resource_groups"],
    ),
    vms=newrelic.cloud.AzureIntegrationsVmsArgs(
        metrics_polling_interval=1200,
        resource_groups=["resource_groups"],
    ),
    vpn_gateway=newrelic.cloud.AzureIntegrationsVpnGatewayArgs(
        metrics_polling_interval=1200,
        resource_groups=["resource_groups"],
    ))

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

const fooAzureLinkAccount = new newrelic.cloud.AzureLinkAccount("fooAzureLinkAccount", {
    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",
});
const fooAzureIntegrations = new newrelic.cloud.AzureIntegrations("fooAzureIntegrations", {
    linkedAccountId: fooAzureLinkAccount.id,
    accountId: "The New Relic account ID",
    apiManagement: {
        metricsPollingInterval: 1200,
        resourceGroups: ["resource_groups"],
    },
    appGateway: {
        metricsPollingInterval: 1200,
        resourceGroups: ["resource_groups"],
    },
    appService: {
        metricsPollingInterval: 1200,
        resourceGroups: ["resource_groups"],
    },
    containers: {
        metricsPollingInterval: 1200,
        resourceGroups: ["resource_groups"],
    },
    cosmosDb: {
        metricsPollingInterval: 1200,
        resourceGroups: ["resource_groups"],
    },
    costManagement: {
        metricsPollingInterval: 3600,
        tagKeys: ["tag_keys"],
    },
    dataFactory: {
        metricsPollingInterval: 1200,
        resourceGroups: ["resource_groups"],
    },
    eventHub: {
        metricsPollingInterval: 1200,
        resourceGroups: ["resource_groups"],
    },
    expressRoute: {
        metricsPollingInterval: 1200,
        resourceGroups: ["resource_groups"],
    },
    firewalls: {
        metricsPollingInterval: 1200,
        resourceGroups: ["resource_groups"],
    },
    frontDoor: {
        metricsPollingInterval: 1200,
        resourceGroups: ["resource_groups"],
    },
    functions: {
        metricsPollingInterval: 1200,
        resourceGroups: ["resource_groups"],
    },
    keyVault: {
        metricsPollingInterval: 1200,
        resourceGroups: ["resource_groups"],
    },
    loadBalancer: {
        metricsPollingInterval: 1200,
        resourceGroups: ["resource_groups"],
    },
    logicApps: {
        metricsPollingInterval: 1200,
        resourceGroups: ["resource_groups"],
    },
    machineLearning: {
        metricsPollingInterval: 1200,
        resourceGroups: ["resource_groups"],
    },
    mariaDb: {
        metricsPollingInterval: 1200,
        resourceGroups: ["resource_groups"],
    },
    monitor: {
        metricsPollingInterval: 1200,
        resourceGroups: ["resource_groups"],
        includeTags: ["env:production"],
        excludeTags: [
            "env:staging",
            "env:testing",
        ],
        enabled: true,
        resourceTypes: ["microsoft.datashare/accounts"],
    },
    mysql: {
        metricsPollingInterval: 1200,
        resourceGroups: ["resource_groups"],
    },
    mysqlFlexible: {
        metricsPollingInterval: 1200,
        resourceGroups: ["resource_groups"],
    },
    postgresql: {
        metricsPollingInterval: 1200,
        resourceGroups: ["resource_groups"],
    },
    postgresqlFlexible: {
        metricsPollingInterval: 1200,
        resourceGroups: ["resource_groups"],
    },
    powerBiDedicated: {
        metricsPollingInterval: 1200,
        resourceGroups: ["resource_groups"],
    },
    redisCache: {
        metricsPollingInterval: 1200,
        resourceGroups: ["resource_groups"],
    },
    serviceBus: {
        metricsPollingInterval: 1200,
        resourceGroups: ["resource_groups"],
    },
    sql: {
        metricsPollingInterval: 1200,
        resourceGroups: ["resource_groups"],
    },
    sqlManaged: {
        metricsPollingInterval: 1200,
        resourceGroups: ["resource_groups"],
    },
    storage: {
        metricsPollingInterval: 1200,
        resourceGroups: ["resource_groups"],
    },
    virtualMachine: {
        metricsPollingInterval: 1200,
        resourceGroups: ["resource_groups"],
    },
    virtualNetworks: {
        metricsPollingInterval: 1200,
        resourceGroups: ["resource_groups"],
    },
    vms: {
        metricsPollingInterval: 1200,
        resourceGroups: ["resource_groups"],
    },
    vpnGateway: {
        metricsPollingInterval: 1200,
        resourceGroups: ["resource_groups"],
    },
});

resources:
  fooAzureLinkAccount:
    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
  fooAzureIntegrations:
    type: newrelic:cloud:AzureIntegrations
    properties:
      linkedAccountId: ${fooAzureLinkAccount.id}
      accountId: The New Relic account ID
      apiManagement:
        metricsPollingInterval: 1200
        resourceGroups:
          - resource_groups
      appGateway:
        metricsPollingInterval: 1200
        resourceGroups:
          - resource_groups
      appService:
        metricsPollingInterval: 1200
        resourceGroups:
          - resource_groups
      containers:
        metricsPollingInterval: 1200
        resourceGroups:
          - resource_groups
      cosmosDb:
        metricsPollingInterval: 1200
        resourceGroups:
          - resource_groups
      costManagement:
        metricsPollingInterval: 3600
        tagKeys:
          - tag_keys
      dataFactory:
        metricsPollingInterval: 1200
        resourceGroups:
          - resource_groups
      eventHub:
        metricsPollingInterval: 1200
        resourceGroups:
          - resource_groups
      expressRoute:
        metricsPollingInterval: 1200
        resourceGroups:
          - resource_groups
      firewalls:
        metricsPollingInterval: 1200
        resourceGroups:
          - resource_groups
      frontDoor:
        metricsPollingInterval: 1200
        resourceGroups:
          - resource_groups
      functions:
        metricsPollingInterval: 1200
        resourceGroups:
          - resource_groups
      keyVault:
        metricsPollingInterval: 1200
        resourceGroups:
          - resource_groups
      loadBalancer:
        metricsPollingInterval: 1200
        resourceGroups:
          - resource_groups
      logicApps:
        metricsPollingInterval: 1200
        resourceGroups:
          - resource_groups
      machineLearning:
        metricsPollingInterval: 1200
        resourceGroups:
          - resource_groups
      mariaDb:
        metricsPollingInterval: 1200
        resourceGroups:
          - resource_groups
      monitor:
        metricsPollingInterval: 1200
        resourceGroups:
          - resource_groups
        includeTags:
          - env:production
        excludeTags:
          - env:staging
          - env:testing
        enabled: true
        resourceTypes:
          - microsoft.datashare/accounts
      mysql:
        metricsPollingInterval: 1200
        resourceGroups:
          - resource_groups
      mysqlFlexible:
        metricsPollingInterval: 1200
        resourceGroups:
          - resource_groups
      postgresql:
        metricsPollingInterval: 1200
        resourceGroups:
          - resource_groups
      postgresqlFlexible:
        metricsPollingInterval: 1200
        resourceGroups:
          - resource_groups
      powerBiDedicated:
        metricsPollingInterval: 1200
        resourceGroups:
          - resource_groups
      redisCache:
        metricsPollingInterval: 1200
        resourceGroups:
          - resource_groups
      serviceBus:
        metricsPollingInterval: 1200
        resourceGroups:
          - resource_groups
      sql:
        metricsPollingInterval: 1200
        resourceGroups:
          - resource_groups
      sqlManaged:
        metricsPollingInterval: 1200
        resourceGroups:
          - resource_groups
      storage:
        metricsPollingInterval: 1200
        resourceGroups:
          - resource_groups
      virtualMachine:
        metricsPollingInterval: 1200
        resourceGroups:
          - resource_groups
      virtualNetworks:
        metricsPollingInterval: 1200
        resourceGroups:
          - resource_groups
      vms:
        metricsPollingInterval: 1200
        resourceGroups:
          - resource_groups
      vpnGateway:
        metricsPollingInterval: 1200
        resourceGroups:
          - resource_groups