Docs Home Pulumi IaC Pulumi ESC Pulumi Cloud Packages Tutorials
  1. Packages
  2. Azure Native
  3. API Docs
  4. datadog
  5. MonitoredSubscription
This is the latest version of Azure Native. Use the Azure Native v1 docs if using the v1 version of this package.
Azure Native v2.73.0 published on Wednesday, Nov 20, 2024 by Pulumi
pulumi/pulumi-azure-native

azure-native.datadog.MonitoredSubscription

Explore with Pulumi AI

azure-native logo
This is the latest version of Azure Native. Use the Azure Native v1 docs if using the v1 version of this package.
Azure Native v2.73.0 published on Wednesday, Nov 20, 2024 by Pulumi
pulumi/pulumi-azure-native

    The request to update subscriptions needed to be monitored by the Datadog monitor resource. Azure REST API version: 2023-01-01.

    Example Usage

    Monitors_AddMonitoredSubscriptions

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

return await Deployment.RunAsync(() => 
{
    var monitoredSubscription = new AzureNative.Datadog.MonitoredSubscription("monitoredSubscription", new()
    {
        ConfigurationName = "default",
        MonitorName = "myMonitor",
        Properties = new AzureNative.Datadog.Inputs.SubscriptionListArgs
        {
            MonitoredSubscriptionList = new[]
            {
                new AzureNative.Datadog.Inputs.MonitoredSubscriptionArgs
                {
                    Status = AzureNative.Datadog.Status.Active,
                    SubscriptionId = "/subscriptions/00000000-0000-0000-0000-000000000000",
                    TagRules = new AzureNative.Datadog.Inputs.MonitoringTagRulesPropertiesArgs
                    {
                        Automuting = true,
                        LogRules = new AzureNative.Datadog.Inputs.LogRulesArgs
                        {
                            FilteringTags = new[]
                            {
                                new AzureNative.Datadog.Inputs.FilteringTagArgs
                                {
                                    Action = AzureNative.Datadog.TagAction.Include,
                                    Name = "Environment",
                                    Value = "Prod",
                                },
                                new AzureNative.Datadog.Inputs.FilteringTagArgs
                                {
                                    Action = AzureNative.Datadog.TagAction.Exclude,
                                    Name = "Environment",
                                    Value = "Dev",
                                },
                            },
                            SendAadLogs = false,
                            SendResourceLogs = true,
                            SendSubscriptionLogs = true,
                        },
                        MetricRules = new AzureNative.Datadog.Inputs.MetricRulesArgs
                        {
                            FilteringTags = new() { },
                        },
                    },
                },
                new AzureNative.Datadog.Inputs.MonitoredSubscriptionArgs
                {
                    Status = AzureNative.Datadog.Status.Failed,
                    SubscriptionId = "/subscriptions/00000000-0000-0000-0000-000000000001",
                    TagRules = new AzureNative.Datadog.Inputs.MonitoringTagRulesPropertiesArgs
                    {
                        Automuting = true,
                        LogRules = new AzureNative.Datadog.Inputs.LogRulesArgs
                        {
                            FilteringTags = new[]
                            {
                                new AzureNative.Datadog.Inputs.FilteringTagArgs
                                {
                                    Action = AzureNative.Datadog.TagAction.Include,
                                    Name = "Environment",
                                    Value = "Prod",
                                },
                                new AzureNative.Datadog.Inputs.FilteringTagArgs
                                {
                                    Action = AzureNative.Datadog.TagAction.Exclude,
                                    Name = "Environment",
                                    Value = "Dev",
                                },
                            },
                            SendAadLogs = false,
                            SendResourceLogs = true,
                            SendSubscriptionLogs = true,
                        },
                        MetricRules = new AzureNative.Datadog.Inputs.MetricRulesArgs
                        {
                            FilteringTags = new() { },
                        },
                    },
                },
            },
            Operation = AzureNative.Datadog.Operation.AddBegin,
        },
        ResourceGroupName = "myResourceGroup",
    });

});

    package main

import (
	datadog "github.com/pulumi/pulumi-azure-native-sdk/datadog/v2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := datadog.NewMonitoredSubscription(ctx, "monitoredSubscription", &datadog.MonitoredSubscriptionArgs{
			ConfigurationName: pulumi.String("default"),
			MonitorName:       pulumi.String("myMonitor"),
			Properties: &datadog.SubscriptionListArgs{
				MonitoredSubscriptionList: datadog.MonitoredSubscriptionTypeArray{
					&datadog.MonitoredSubscriptionTypeArgs{
						Status:         pulumi.String(datadog.StatusActive),
						SubscriptionId: pulumi.String("/subscriptions/00000000-0000-0000-0000-000000000000"),
						TagRules: &datadog.MonitoringTagRulesPropertiesArgs{
							Automuting: pulumi.Bool(true),
							LogRules: &datadog.LogRulesArgs{
								FilteringTags: datadog.FilteringTagArray{
									&datadog.FilteringTagArgs{
										Action: pulumi.String(datadog.TagActionInclude),
										Name:   pulumi.String("Environment"),
										Value:  pulumi.String("Prod"),
									},
									&datadog.FilteringTagArgs{
										Action: pulumi.String(datadog.TagActionExclude),
										Name:   pulumi.String("Environment"),
										Value:  pulumi.String("Dev"),
									},
								},
								SendAadLogs:          pulumi.Bool(false),
								SendResourceLogs:     pulumi.Bool(true),
								SendSubscriptionLogs: pulumi.Bool(true),
							},
							MetricRules: &datadog.MetricRulesArgs{
								FilteringTags: datadog.FilteringTagArray{},
							},
						},
					},
					&datadog.MonitoredSubscriptionTypeArgs{
						Status:         pulumi.String(datadog.StatusFailed),
						SubscriptionId: pulumi.String("/subscriptions/00000000-0000-0000-0000-000000000001"),
						TagRules: &datadog.MonitoringTagRulesPropertiesArgs{
							Automuting: pulumi.Bool(true),
							LogRules: &datadog.LogRulesArgs{
								FilteringTags: datadog.FilteringTagArray{
									&datadog.FilteringTagArgs{
										Action: pulumi.String(datadog.TagActionInclude),
										Name:   pulumi.String("Environment"),
										Value:  pulumi.String("Prod"),
									},
									&datadog.FilteringTagArgs{
										Action: pulumi.String(datadog.TagActionExclude),
										Name:   pulumi.String("Environment"),
										Value:  pulumi.String("Dev"),
									},
								},
								SendAadLogs:          pulumi.Bool(false),
								SendResourceLogs:     pulumi.Bool(true),
								SendSubscriptionLogs: pulumi.Bool(true),
							},
							MetricRules: &datadog.MetricRulesArgs{
								FilteringTags: datadog.FilteringTagArray{},
							},
						},
					},
				},
				Operation: pulumi.String(datadog.OperationAddBegin),
			},
			ResourceGroupName: pulumi.String("myResourceGroup"),
		})
		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.azurenative.datadog.MonitoredSubscription;
import com.pulumi.azurenative.datadog.MonitoredSubscriptionArgs;
import com.pulumi.azurenative.datadog.inputs.SubscriptionListArgs;
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 monitoredSubscription = new MonitoredSubscription("monitoredSubscription", MonitoredSubscriptionArgs.builder()
            .configurationName("default")
            .monitorName("myMonitor")
            .properties(SubscriptionListArgs.builder()
                .monitoredSubscriptionList(                
                    MonitoredSubscriptionArgs.builder()
                        .status("Active")
                        .subscriptionId("/subscriptions/00000000-0000-0000-0000-000000000000")
                        .tagRules(MonitoringTagRulesPropertiesArgs.builder()
                            .automuting(true)
                            .logRules(LogRulesArgs.builder()
                                .filteringTags(                                
                                    FilteringTagArgs.builder()
                                        .action("Include")
                                        .name("Environment")
                                        .value("Prod")
                                        .build(),
                                    FilteringTagArgs.builder()
                                        .action("Exclude")
                                        .name("Environment")
                                        .value("Dev")
                                        .build())
                                .sendAadLogs(false)
                                .sendResourceLogs(true)
                                .sendSubscriptionLogs(true)
                                .build())
                            .metricRules(MetricRulesArgs.builder()
                                .filteringTags()
                                .build())
                            .build())
                        .build(),
                    MonitoredSubscriptionArgs.builder()
                        .status("Failed")
                        .subscriptionId("/subscriptions/00000000-0000-0000-0000-000000000001")
                        .tagRules(MonitoringTagRulesPropertiesArgs.builder()
                            .automuting(true)
                            .logRules(LogRulesArgs.builder()
                                .filteringTags(                                
                                    FilteringTagArgs.builder()
                                        .action("Include")
                                        .name("Environment")
                                        .value("Prod")
                                        .build(),
                                    FilteringTagArgs.builder()
                                        .action("Exclude")
                                        .name("Environment")
                                        .value("Dev")
                                        .build())
                                .sendAadLogs(false)
                                .sendResourceLogs(true)
                                .sendSubscriptionLogs(true)
                                .build())
                            .metricRules(MetricRulesArgs.builder()
                                .filteringTags()
                                .build())
                            .build())
                        .build())
                .operation("AddBegin")
                .build())
            .resourceGroupName("myResourceGroup")
            .build());

    }
}

    import pulumi
import pulumi_azure_native as azure_native

monitored_subscription = azure_native.datadog.MonitoredSubscription("monitoredSubscription",
    configuration_name="default",
    monitor_name="myMonitor",
    properties={
        "monitored_subscription_list": [
            {
                "status": azure_native.datadog.Status.ACTIVE,
                "subscription_id": "/subscriptions/00000000-0000-0000-0000-000000000000",
                "tag_rules": {
                    "automuting": True,
                    "log_rules": {
                        "filtering_tags": [
                            {
                                "action": azure_native.datadog.TagAction.INCLUDE,
                                "name": "Environment",
                                "value": "Prod",
                            },
                            {
                                "action": azure_native.datadog.TagAction.EXCLUDE,
                                "name": "Environment",
                                "value": "Dev",
                            },
                        ],
                        "send_aad_logs": False,
                        "send_resource_logs": True,
                        "send_subscription_logs": True,
                    },
                    "metric_rules": {
                        "filtering_tags": [],
                    },
                },
            },
            {
                "status": azure_native.datadog.Status.FAILED,
                "subscription_id": "/subscriptions/00000000-0000-0000-0000-000000000001",
                "tag_rules": {
                    "automuting": True,
                    "log_rules": {
                        "filtering_tags": [
                            {
                                "action": azure_native.datadog.TagAction.INCLUDE,
                                "name": "Environment",
                                "value": "Prod",
                            },
                            {
                                "action": azure_native.datadog.TagAction.EXCLUDE,
                                "name": "Environment",
                                "value": "Dev",
                            },
                        ],
                        "send_aad_logs": False,
                        "send_resource_logs": True,
                        "send_subscription_logs": True,
                    },
                    "metric_rules": {
                        "filtering_tags": [],
                    },
                },
            },
        ],
        "operation": azure_native.datadog.Operation.ADD_BEGIN,
    },
    resource_group_name="myResourceGroup")

    import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";

const monitoredSubscription = new azure_native.datadog.MonitoredSubscription("monitoredSubscription", {
    configurationName: "default",
    monitorName: "myMonitor",
    properties: {
        monitoredSubscriptionList: [
            {
                status: azure_native.datadog.Status.Active,
                subscriptionId: "/subscriptions/00000000-0000-0000-0000-000000000000",
                tagRules: {
                    automuting: true,
                    logRules: {
                        filteringTags: [
                            {
                                action: azure_native.datadog.TagAction.Include,
                                name: "Environment",
                                value: "Prod",
                            },
                            {
                                action: azure_native.datadog.TagAction.Exclude,
                                name: "Environment",
                                value: "Dev",
                            },
                        ],
                        sendAadLogs: false,
                        sendResourceLogs: true,
                        sendSubscriptionLogs: true,
                    },
                    metricRules: {
                        filteringTags: [],
                    },
                },
            },
            {
                status: azure_native.datadog.Status.Failed,
                subscriptionId: "/subscriptions/00000000-0000-0000-0000-000000000001",
                tagRules: {
                    automuting: true,
                    logRules: {
                        filteringTags: [
                            {
                                action: azure_native.datadog.TagAction.Include,
                                name: "Environment",
                                value: "Prod",
                            },
                            {
                                action: azure_native.datadog.TagAction.Exclude,
                                name: "Environment",
                                value: "Dev",
                            },
                        ],
                        sendAadLogs: false,
                        sendResourceLogs: true,
                        sendSubscriptionLogs: true,
                    },
                    metricRules: {
                        filteringTags: [],
                    },
                },
            },
        ],
        operation: azure_native.datadog.Operation.AddBegin,
    },
    resourceGroupName: "myResourceGroup",
});

    resources:
  monitoredSubscription:
    type: azure-native:datadog:MonitoredSubscription
    properties:
      configurationName: default
      monitorName: myMonitor
      properties:
        monitoredSubscriptionList:
          - status: Active
            subscriptionId: /subscriptions/00000000-0000-0000-0000-000000000000
            tagRules:
              automuting: true
              logRules:
                filteringTags:
                  - action: Include
                    name: Environment
                    value: Prod
                  - action: Exclude
                    name: Environment
                    value: Dev
                sendAadLogs: false
                sendResourceLogs: true
                sendSubscriptionLogs: true
              metricRules:
                filteringTags: []
          - status: Failed
            subscriptionId: /subscriptions/00000000-0000-0000-0000-000000000001
            tagRules:
              automuting: true
              logRules:
                filteringTags:
                  - action: Include
                    name: Environment
                    value: Prod
                  - action: Exclude
                    name: Environment
                    value: Dev
                sendAadLogs: false
                sendResourceLogs: true
                sendSubscriptionLogs: true
              metricRules:
                filteringTags: []
        operation: AddBegin
      resourceGroupName: myResourceGroup

    Create MonitoredSubscription Resource

    Resources are created with functions called constructors. To learn more about declaring and configuring resources, see Resources.

    Constructor syntax

    new MonitoredSubscription(name: string, args: MonitoredSubscriptionArgs, opts?: CustomResourceOptions);
    @overload
def MonitoredSubscription(resource_name: str,
                          args: MonitoredSubscriptionInitArgs,
                          opts: Optional[ResourceOptions] = None)

@overload
def MonitoredSubscription(resource_name: str,
                          opts: Optional[ResourceOptions] = None,
                          monitor_name: Optional[str] = None,
                          resource_group_name: Optional[str] = None,
                          configuration_name: Optional[str] = None,
                          properties: Optional[SubscriptionListArgs] = None)
    func NewMonitoredSubscription(ctx *Context, name string, args MonitoredSubscriptionArgs, opts ...ResourceOption) (*MonitoredSubscription, error)
    public MonitoredSubscription(string name, MonitoredSubscriptionArgs args, CustomResourceOptions? opts = null)
    public MonitoredSubscription(String name, MonitoredSubscriptionArgs args)
public MonitoredSubscription(String name, MonitoredSubscriptionArgs args, CustomResourceOptions options)

    type: azure-native:datadog:MonitoredSubscription
properties: # The arguments to resource properties.
options: # Bag of options to control resource's behavior.

    Parameters

    name string
    The unique name of the resource.
    args MonitoredSubscriptionArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    resource_name str
    The unique name of the resource.
    args MonitoredSubscriptionInitArgs
    The arguments to resource properties.
    opts ResourceOptions
    Bag of options to control resource's behavior.
    ctx Context
    Context object for the current deployment.
    name string
    The unique name of the resource.
    args MonitoredSubscriptionArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args MonitoredSubscriptionArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args MonitoredSubscriptionArgs
    The arguments to resource properties.
    options CustomResourceOptions
    Bag of options to control resource's behavior.

    Constructor example

    The following reference example uses placeholder values for all input properties.

    var monitoredSubscriptionResource = new AzureNative.Datadog.MonitoredSubscription("monitoredSubscriptionResource", new()
{
    MonitorName = "string",
    ResourceGroupName = "string",
    ConfigurationName = "string",
    Properties = new AzureNative.Datadog.Inputs.SubscriptionListArgs
    {
        MonitoredSubscriptionList = new[]
        {
            new AzureNative.Datadog.Inputs.MonitoredSubscriptionArgs
            {
                Error = "string",
                Status = "string",
                SubscriptionId = "string",
                TagRules = new AzureNative.Datadog.Inputs.MonitoringTagRulesPropertiesArgs
                {
                    Automuting = false,
                    LogRules = new AzureNative.Datadog.Inputs.LogRulesArgs
                    {
                        FilteringTags = new[]
                        {
                            new AzureNative.Datadog.Inputs.FilteringTagArgs
                            {
                                Action = "string",
                                Name = "string",
                                Value = "string",
                            },
                        },
                        SendAadLogs = false,
                        SendResourceLogs = false,
                        SendSubscriptionLogs = false,
                    },
                    MetricRules = new AzureNative.Datadog.Inputs.MetricRulesArgs
                    {
                        FilteringTags = new[]
                        {
                            new AzureNative.Datadog.Inputs.FilteringTagArgs
                            {
                                Action = "string",
                                Name = "string",
                                Value = "string",
                            },
                        },
                    },
                },
            },
        },
        Operation = "string",
    },
});

    example, err := datadog.NewMonitoredSubscription(ctx, "monitoredSubscriptionResource", &datadog.MonitoredSubscriptionArgs{
	MonitorName:       pulumi.String("string"),
	ResourceGroupName: pulumi.String("string"),
	ConfigurationName: pulumi.String("string"),
	Properties: &datadog.SubscriptionListArgs{
		MonitoredSubscriptionList: datadog.MonitoredSubscriptionTypeArray{
			&datadog.MonitoredSubscriptionTypeArgs{
				Error:          pulumi.String("string"),
				Status:         pulumi.String("string"),
				SubscriptionId: pulumi.String("string"),
				TagRules: &datadog.MonitoringTagRulesPropertiesArgs{
					Automuting: pulumi.Bool(false),
					LogRules: &datadog.LogRulesArgs{
						FilteringTags: datadog.FilteringTagArray{
							&datadog.FilteringTagArgs{
								Action: pulumi.String("string"),
								Name:   pulumi.String("string"),
								Value:  pulumi.String("string"),
							},
						},
						SendAadLogs:          pulumi.Bool(false),
						SendResourceLogs:     pulumi.Bool(false),
						SendSubscriptionLogs: pulumi.Bool(false),
					},
					MetricRules: &datadog.MetricRulesArgs{
						FilteringTags: datadog.FilteringTagArray{
							&datadog.FilteringTagArgs{
								Action: pulumi.String("string"),
								Name:   pulumi.String("string"),
								Value:  pulumi.String("string"),
							},
						},
					},
				},
			},
		},
		Operation: pulumi.String("string"),
	},
})

    var monitoredSubscriptionResource = new MonitoredSubscription("monitoredSubscriptionResource", MonitoredSubscriptionArgs.builder()
    .monitorName("string")
    .resourceGroupName("string")
    .configurationName("string")
    .properties(SubscriptionListArgs.builder()
        .monitoredSubscriptionList(MonitoredSubscriptionArgs.builder()
            .error("string")
            .status("string")
            .subscriptionId("string")
            .tagRules(MonitoringTagRulesPropertiesArgs.builder()
                .automuting(false)
                .logRules(LogRulesArgs.builder()
                    .filteringTags(FilteringTagArgs.builder()
                        .action("string")
                        .name("string")
                        .value("string")
                        .build())
                    .sendAadLogs(false)
                    .sendResourceLogs(false)
                    .sendSubscriptionLogs(false)
                    .build())
                .metricRules(MetricRulesArgs.builder()
                    .filteringTags(FilteringTagArgs.builder()
                        .action("string")
                        .name("string")
                        .value("string")
                        .build())
                    .build())
                .build())
            .build())
        .operation("string")
        .build())
    .build());

    monitored_subscription_resource = azure_native.datadog.MonitoredSubscription("monitoredSubscriptionResource",
    monitor_name="string",
    resource_group_name="string",
    configuration_name="string",
    properties={
        "monitored_subscription_list": [{
            "error": "string",
            "status": "string",
            "subscription_id": "string",
            "tag_rules": {
                "automuting": False,
                "log_rules": {
                    "filtering_tags": [{
                        "action": "string",
                        "name": "string",
                        "value": "string",
                    }],
                    "send_aad_logs": False,
                    "send_resource_logs": False,
                    "send_subscription_logs": False,
                },
                "metric_rules": {
                    "filtering_tags": [{
                        "action": "string",
                        "name": "string",
                        "value": "string",
                    }],
                },
            },
        }],
        "operation": "string",
    })

    const monitoredSubscriptionResource = new azure_native.datadog.MonitoredSubscription("monitoredSubscriptionResource", {
    monitorName: "string",
    resourceGroupName: "string",
    configurationName: "string",
    properties: {
        monitoredSubscriptionList: [{
            error: "string",
            status: "string",
            subscriptionId: "string",
            tagRules: {
                automuting: false,
                logRules: {
                    filteringTags: [{
                        action: "string",
                        name: "string",
                        value: "string",
                    }],
                    sendAadLogs: false,
                    sendResourceLogs: false,
                    sendSubscriptionLogs: false,
                },
                metricRules: {
                    filteringTags: [{
                        action: "string",
                        name: "string",
                        value: "string",
                    }],
                },
            },
        }],
        operation: "string",
    },
});

    type: azure-native:datadog:MonitoredSubscription
properties:
    configurationName: string
    monitorName: string
    properties:
        monitoredSubscriptionList:
            - error: string
              status: string
              subscriptionId: string
              tagRules:
                automuting: false
                logRules:
                    filteringTags:
                        - action: string
                          name: string
                          value: string
                    sendAadLogs: false
                    sendResourceLogs: false
                    sendSubscriptionLogs: false
                metricRules:
                    filteringTags:
                        - action: string
                          name: string
                          value: string
        operation: string
    resourceGroupName: string

    MonitoredSubscription Resource Properties

    To learn more about resource properties and how to use them, see Inputs and Outputs in the Architecture and Concepts docs.

    Inputs

    In Python, inputs that are objects can be passed either as argument classes or as dictionary literals.

    The MonitoredSubscription resource accepts the following input properties:

    MonitorName string
    Monitor resource name
    ResourceGroupName string
    The name of the resource group. The name is case insensitive.
    ConfigurationName string
    The configuration name. Only 'default' value is supported.
    Properties Pulumi.AzureNative.Datadog.Inputs.SubscriptionList
    The request to update subscriptions needed to be monitored by the Datadog monitor resource.
    MonitorName string
    Monitor resource name
    ResourceGroupName string
    The name of the resource group. The name is case insensitive.
    ConfigurationName string
    The configuration name. Only 'default' value is supported.
    Properties SubscriptionListArgs
    The request to update subscriptions needed to be monitored by the Datadog monitor resource.
    monitorName String
    Monitor resource name
    resourceGroupName String
    The name of the resource group. The name is case insensitive.
    configurationName String
    The configuration name. Only 'default' value is supported.
    properties SubscriptionList
    The request to update subscriptions needed to be monitored by the Datadog monitor resource.
    monitorName string
    Monitor resource name
    resourceGroupName string
    The name of the resource group. The name is case insensitive.
    configurationName string
    The configuration name. Only 'default' value is supported.
    properties SubscriptionList
    The request to update subscriptions needed to be monitored by the Datadog monitor resource.
    monitor_name str
    Monitor resource name
    resource_group_name str
    The name of the resource group. The name is case insensitive.
    configuration_name str
    The configuration name. Only 'default' value is supported.
    properties SubscriptionListArgs
    The request to update subscriptions needed to be monitored by the Datadog monitor resource.
    monitorName String
    Monitor resource name
    resourceGroupName String
    The name of the resource group. The name is case insensitive.
    configurationName String
    The configuration name. Only 'default' value is supported.
    properties Property Map
    The request to update subscriptions needed to be monitored by the Datadog monitor resource.

    Outputs

    All input properties are implicitly available as output properties. Additionally, the MonitoredSubscription resource produces the following output properties:

    Id string
    The provider-assigned unique ID for this managed resource.
    Name string
    Name of the monitored subscription resource.
    Type string
    The type of the monitored subscription resource.
    Id string
    The provider-assigned unique ID for this managed resource.
    Name string
    Name of the monitored subscription resource.
    Type string
    The type of the monitored subscription resource.
    id String
    The provider-assigned unique ID for this managed resource.
    name String
    Name of the monitored subscription resource.
    type String
    The type of the monitored subscription resource.
    id string
    The provider-assigned unique ID for this managed resource.
    name string
    Name of the monitored subscription resource.
    type string
    The type of the monitored subscription resource.
    id str
    The provider-assigned unique ID for this managed resource.
    name str
    Name of the monitored subscription resource.
    type str
    The type of the monitored subscription resource.
    id String
    The provider-assigned unique ID for this managed resource.
    name String
    Name of the monitored subscription resource.
    type String
    The type of the monitored subscription resource.

    Supporting Types

    FilteringTag, FilteringTagArgs

    Action string | Pulumi.AzureNative.Datadog.TagAction
    Valid actions for a filtering tag. Exclusion takes priority over inclusion.
    Name string
    The name (also known as the key) of the tag.
    Value string
    The value of the tag.
    Action string | TagAction
    Valid actions for a filtering tag. Exclusion takes priority over inclusion.
    Name string
    The name (also known as the key) of the tag.
    Value string
    The value of the tag.
    action String | TagAction
    Valid actions for a filtering tag. Exclusion takes priority over inclusion.
    name String
    The name (also known as the key) of the tag.
    value String
    The value of the tag.
    action string | TagAction
    Valid actions for a filtering tag. Exclusion takes priority over inclusion.
    name string
    The name (also known as the key) of the tag.
    value string
    The value of the tag.
    action str | TagAction
    Valid actions for a filtering tag. Exclusion takes priority over inclusion.
    name str
    The name (also known as the key) of the tag.
    value str
    The value of the tag.
    action String | "Include" | "Exclude"
    Valid actions for a filtering tag. Exclusion takes priority over inclusion.
    name String
    The name (also known as the key) of the tag.
    value String
    The value of the tag.

    FilteringTagResponse, FilteringTagResponseArgs

    Action string
    Valid actions for a filtering tag. Exclusion takes priority over inclusion.
    Name string
    The name (also known as the key) of the tag.
    Value string
    The value of the tag.
    Action string
    Valid actions for a filtering tag. Exclusion takes priority over inclusion.
    Name string
    The name (also known as the key) of the tag.
    Value string
    The value of the tag.
    action String
    Valid actions for a filtering tag. Exclusion takes priority over inclusion.
    name String
    The name (also known as the key) of the tag.
    value String
    The value of the tag.
    action string
    Valid actions for a filtering tag. Exclusion takes priority over inclusion.
    name string
    The name (also known as the key) of the tag.
    value string
    The value of the tag.
    action str
    Valid actions for a filtering tag. Exclusion takes priority over inclusion.
    name str
    The name (also known as the key) of the tag.
    value str
    The value of the tag.
    action String
    Valid actions for a filtering tag. Exclusion takes priority over inclusion.
    name String
    The name (also known as the key) of the tag.
    value String
    The value of the tag.

    LogRules, LogRulesArgs

    FilteringTags List<Pulumi.AzureNative.Datadog.Inputs.FilteringTag>
    List of filtering tags to be used for capturing logs. This only takes effect if SendResourceLogs flag is enabled. If empty, all resources will be captured. If only Exclude action is specified, the rules will apply to the list of all available resources. If Include actions are specified, the rules will only include resources with the associated tags.
    SendAadLogs bool
    Flag specifying if AAD logs should be sent for the Monitor resource.
    SendResourceLogs bool
    Flag specifying if Azure resource logs should be sent for the Monitor resource.
    SendSubscriptionLogs bool
    Flag specifying if Azure subscription logs should be sent for the Monitor resource.
    FilteringTags []FilteringTag
    List of filtering tags to be used for capturing logs. This only takes effect if SendResourceLogs flag is enabled. If empty, all resources will be captured. If only Exclude action is specified, the rules will apply to the list of all available resources. If Include actions are specified, the rules will only include resources with the associated tags.
    SendAadLogs bool
    Flag specifying if AAD logs should be sent for the Monitor resource.
    SendResourceLogs bool
    Flag specifying if Azure resource logs should be sent for the Monitor resource.
    SendSubscriptionLogs bool
    Flag specifying if Azure subscription logs should be sent for the Monitor resource.
    filteringTags List<FilteringTag>
    List of filtering tags to be used for capturing logs. This only takes effect if SendResourceLogs flag is enabled. If empty, all resources will be captured. If only Exclude action is specified, the rules will apply to the list of all available resources. If Include actions are specified, the rules will only include resources with the associated tags.
    sendAadLogs Boolean
    Flag specifying if AAD logs should be sent for the Monitor resource.
    sendResourceLogs Boolean
    Flag specifying if Azure resource logs should be sent for the Monitor resource.
    sendSubscriptionLogs Boolean
    Flag specifying if Azure subscription logs should be sent for the Monitor resource.
    filteringTags FilteringTag[]
    List of filtering tags to be used for capturing logs. This only takes effect if SendResourceLogs flag is enabled. If empty, all resources will be captured. If only Exclude action is specified, the rules will apply to the list of all available resources. If Include actions are specified, the rules will only include resources with the associated tags.
    sendAadLogs boolean
    Flag specifying if AAD logs should be sent for the Monitor resource.
    sendResourceLogs boolean
    Flag specifying if Azure resource logs should be sent for the Monitor resource.
    sendSubscriptionLogs boolean
    Flag specifying if Azure subscription logs should be sent for the Monitor resource.
    filtering_tags Sequence[FilteringTag]
    List of filtering tags to be used for capturing logs. This only takes effect if SendResourceLogs flag is enabled. If empty, all resources will be captured. If only Exclude action is specified, the rules will apply to the list of all available resources. If Include actions are specified, the rules will only include resources with the associated tags.
    send_aad_logs bool
    Flag specifying if AAD logs should be sent for the Monitor resource.
    send_resource_logs bool
    Flag specifying if Azure resource logs should be sent for the Monitor resource.
    send_subscription_logs bool
    Flag specifying if Azure subscription logs should be sent for the Monitor resource.
    filteringTags List<Property Map>
    List of filtering tags to be used for capturing logs. This only takes effect if SendResourceLogs flag is enabled. If empty, all resources will be captured. If only Exclude action is specified, the rules will apply to the list of all available resources. If Include actions are specified, the rules will only include resources with the associated tags.
    sendAadLogs Boolean
    Flag specifying if AAD logs should be sent for the Monitor resource.
    sendResourceLogs Boolean
    Flag specifying if Azure resource logs should be sent for the Monitor resource.
    sendSubscriptionLogs Boolean
    Flag specifying if Azure subscription logs should be sent for the Monitor resource.

    LogRulesResponse, LogRulesResponseArgs

    FilteringTags List<Pulumi.AzureNative.Datadog.Inputs.FilteringTagResponse>
    List of filtering tags to be used for capturing logs. This only takes effect if SendResourceLogs flag is enabled. If empty, all resources will be captured. If only Exclude action is specified, the rules will apply to the list of all available resources. If Include actions are specified, the rules will only include resources with the associated tags.
    SendAadLogs bool
    Flag specifying if AAD logs should be sent for the Monitor resource.
    SendResourceLogs bool
    Flag specifying if Azure resource logs should be sent for the Monitor resource.
    SendSubscriptionLogs bool
    Flag specifying if Azure subscription logs should be sent for the Monitor resource.
    FilteringTags []FilteringTagResponse
    List of filtering tags to be used for capturing logs. This only takes effect if SendResourceLogs flag is enabled. If empty, all resources will be captured. If only Exclude action is specified, the rules will apply to the list of all available resources. If Include actions are specified, the rules will only include resources with the associated tags.
    SendAadLogs bool
    Flag specifying if AAD logs should be sent for the Monitor resource.
    SendResourceLogs bool
    Flag specifying if Azure resource logs should be sent for the Monitor resource.
    SendSubscriptionLogs bool
    Flag specifying if Azure subscription logs should be sent for the Monitor resource.
    filteringTags List<FilteringTagResponse>
    List of filtering tags to be used for capturing logs. This only takes effect if SendResourceLogs flag is enabled. If empty, all resources will be captured. If only Exclude action is specified, the rules will apply to the list of all available resources. If Include actions are specified, the rules will only include resources with the associated tags.
    sendAadLogs Boolean
    Flag specifying if AAD logs should be sent for the Monitor resource.
    sendResourceLogs Boolean
    Flag specifying if Azure resource logs should be sent for the Monitor resource.
    sendSubscriptionLogs Boolean
    Flag specifying if Azure subscription logs should be sent for the Monitor resource.
    filteringTags FilteringTagResponse[]
    List of filtering tags to be used for capturing logs. This only takes effect if SendResourceLogs flag is enabled. If empty, all resources will be captured. If only Exclude action is specified, the rules will apply to the list of all available resources. If Include actions are specified, the rules will only include resources with the associated tags.
    sendAadLogs boolean
    Flag specifying if AAD logs should be sent for the Monitor resource.
    sendResourceLogs boolean
    Flag specifying if Azure resource logs should be sent for the Monitor resource.
    sendSubscriptionLogs boolean
    Flag specifying if Azure subscription logs should be sent for the Monitor resource.
    filtering_tags Sequence[FilteringTagResponse]
    List of filtering tags to be used for capturing logs. This only takes effect if SendResourceLogs flag is enabled. If empty, all resources will be captured. If only Exclude action is specified, the rules will apply to the list of all available resources. If Include actions are specified, the rules will only include resources with the associated tags.
    send_aad_logs bool
    Flag specifying if AAD logs should be sent for the Monitor resource.
    send_resource_logs bool
    Flag specifying if Azure resource logs should be sent for the Monitor resource.
    send_subscription_logs bool
    Flag specifying if Azure subscription logs should be sent for the Monitor resource.
    filteringTags List<Property Map>
    List of filtering tags to be used for capturing logs. This only takes effect if SendResourceLogs flag is enabled. If empty, all resources will be captured. If only Exclude action is specified, the rules will apply to the list of all available resources. If Include actions are specified, the rules will only include resources with the associated tags.
    sendAadLogs Boolean
    Flag specifying if AAD logs should be sent for the Monitor resource.
    sendResourceLogs Boolean
    Flag specifying if Azure resource logs should be sent for the Monitor resource.
    sendSubscriptionLogs Boolean
    Flag specifying if Azure subscription logs should be sent for the Monitor resource.

    MetricRules, MetricRulesArgs

    FilteringTags List<Pulumi.AzureNative.Datadog.Inputs.FilteringTag>
    List of filtering tags to be used for capturing metrics. If empty, all resources will be captured. If only Exclude action is specified, the rules will apply to the list of all available resources. If Include actions are specified, the rules will only include resources with the associated tags.
    FilteringTags []FilteringTag
    List of filtering tags to be used for capturing metrics. If empty, all resources will be captured. If only Exclude action is specified, the rules will apply to the list of all available resources. If Include actions are specified, the rules will only include resources with the associated tags.
    filteringTags List<FilteringTag>
    List of filtering tags to be used for capturing metrics. If empty, all resources will be captured. If only Exclude action is specified, the rules will apply to the list of all available resources. If Include actions are specified, the rules will only include resources with the associated tags.
    filteringTags FilteringTag[]
    List of filtering tags to be used for capturing metrics. If empty, all resources will be captured. If only Exclude action is specified, the rules will apply to the list of all available resources. If Include actions are specified, the rules will only include resources with the associated tags.
    filtering_tags Sequence[FilteringTag]
    List of filtering tags to be used for capturing metrics. If empty, all resources will be captured. If only Exclude action is specified, the rules will apply to the list of all available resources. If Include actions are specified, the rules will only include resources with the associated tags.
    filteringTags List<Property Map>
    List of filtering tags to be used for capturing metrics. If empty, all resources will be captured. If only Exclude action is specified, the rules will apply to the list of all available resources. If Include actions are specified, the rules will only include resources with the associated tags.

    MetricRulesResponse, MetricRulesResponseArgs

    FilteringTags List<Pulumi.AzureNative.Datadog.Inputs.FilteringTagResponse>
    List of filtering tags to be used for capturing metrics. If empty, all resources will be captured. If only Exclude action is specified, the rules will apply to the list of all available resources. If Include actions are specified, the rules will only include resources with the associated tags.
    FilteringTags []FilteringTagResponse
    List of filtering tags to be used for capturing metrics. If empty, all resources will be captured. If only Exclude action is specified, the rules will apply to the list of all available resources. If Include actions are specified, the rules will only include resources with the associated tags.
    filteringTags List<FilteringTagResponse>
    List of filtering tags to be used for capturing metrics. If empty, all resources will be captured. If only Exclude action is specified, the rules will apply to the list of all available resources. If Include actions are specified, the rules will only include resources with the associated tags.
    filteringTags FilteringTagResponse[]
    List of filtering tags to be used for capturing metrics. If empty, all resources will be captured. If only Exclude action is specified, the rules will apply to the list of all available resources. If Include actions are specified, the rules will only include resources with the associated tags.
    filtering_tags Sequence[FilteringTagResponse]
    List of filtering tags to be used for capturing metrics. If empty, all resources will be captured. If only Exclude action is specified, the rules will apply to the list of all available resources. If Include actions are specified, the rules will only include resources with the associated tags.
    filteringTags List<Property Map>
    List of filtering tags to be used for capturing metrics. If empty, all resources will be captured. If only Exclude action is specified, the rules will apply to the list of all available resources. If Include actions are specified, the rules will only include resources with the associated tags.

    MonitoredSubscription, MonitoredSubscriptionArgs

    Error string
    The reason of not monitoring the subscription.
    Status string | Pulumi.AzureNative.Datadog.Status
    The state of monitoring.
    SubscriptionId string
    The subscriptionId to be monitored.
    TagRules Pulumi.AzureNative.Datadog.Inputs.MonitoringTagRulesProperties
    Definition of the properties for a TagRules resource.
    Error string
    The reason of not monitoring the subscription.
    Status string | Status
    The state of monitoring.
    SubscriptionId string
    The subscriptionId to be monitored.
    TagRules MonitoringTagRulesProperties
    Definition of the properties for a TagRules resource.
    error String
    The reason of not monitoring the subscription.
    status String | Status
    The state of monitoring.
    subscriptionId String
    The subscriptionId to be monitored.
    tagRules MonitoringTagRulesProperties
    Definition of the properties for a TagRules resource.
    error string
    The reason of not monitoring the subscription.
    status string | Status
    The state of monitoring.
    subscriptionId string
    The subscriptionId to be monitored.
    tagRules MonitoringTagRulesProperties
    Definition of the properties for a TagRules resource.
    error str
    The reason of not monitoring the subscription.
    status str | Status
    The state of monitoring.
    subscription_id str
    The subscriptionId to be monitored.
    tag_rules MonitoringTagRulesProperties
    Definition of the properties for a TagRules resource.
    error String
    The reason of not monitoring the subscription.
    status String | "InProgress" | "Active" | "Failed" | "Deleting"
    The state of monitoring.
    subscriptionId String
    The subscriptionId to be monitored.
    tagRules Property Map
    Definition of the properties for a TagRules resource.

    MonitoredSubscriptionResponse, MonitoredSubscriptionResponseArgs

    Error string
    The reason of not monitoring the subscription.
    Status string
    The state of monitoring.
    SubscriptionId string
    The subscriptionId to be monitored.
    TagRules Pulumi.AzureNative.Datadog.Inputs.MonitoringTagRulesPropertiesResponse
    Definition of the properties for a TagRules resource.
    Error string
    The reason of not monitoring the subscription.
    Status string
    The state of monitoring.
    SubscriptionId string
    The subscriptionId to be monitored.
    TagRules MonitoringTagRulesPropertiesResponse
    Definition of the properties for a TagRules resource.
    error String
    The reason of not monitoring the subscription.
    status String
    The state of monitoring.
    subscriptionId String
    The subscriptionId to be monitored.
    tagRules MonitoringTagRulesPropertiesResponse
    Definition of the properties for a TagRules resource.
    error string
    The reason of not monitoring the subscription.
    status string
    The state of monitoring.
    subscriptionId string
    The subscriptionId to be monitored.
    tagRules MonitoringTagRulesPropertiesResponse
    Definition of the properties for a TagRules resource.
    error str
    The reason of not monitoring the subscription.
    status str
    The state of monitoring.
    subscription_id str
    The subscriptionId to be monitored.
    tag_rules MonitoringTagRulesPropertiesResponse
    Definition of the properties for a TagRules resource.
    error String
    The reason of not monitoring the subscription.
    status String
    The state of monitoring.
    subscriptionId String
    The subscriptionId to be monitored.
    tagRules Property Map
    Definition of the properties for a TagRules resource.

    MonitoringTagRulesProperties, MonitoringTagRulesPropertiesArgs

    Automuting bool
    Configuration to enable/disable auto-muting flag
    LogRules Pulumi.AzureNative.Datadog.Inputs.LogRules
    Set of rules for sending logs for the Monitor resource.
    MetricRules Pulumi.AzureNative.Datadog.Inputs.MetricRules
    Set of rules for sending metrics for the Monitor resource.
    Automuting bool
    Configuration to enable/disable auto-muting flag
    LogRules LogRules
    Set of rules for sending logs for the Monitor resource.
    MetricRules MetricRules
    Set of rules for sending metrics for the Monitor resource.
    automuting Boolean
    Configuration to enable/disable auto-muting flag
    logRules LogRules
    Set of rules for sending logs for the Monitor resource.
    metricRules MetricRules
    Set of rules for sending metrics for the Monitor resource.
    automuting boolean
    Configuration to enable/disable auto-muting flag
    logRules LogRules
    Set of rules for sending logs for the Monitor resource.
    metricRules MetricRules
    Set of rules for sending metrics for the Monitor resource.
    automuting bool
    Configuration to enable/disable auto-muting flag
    log_rules LogRules
    Set of rules for sending logs for the Monitor resource.
    metric_rules MetricRules
    Set of rules for sending metrics for the Monitor resource.
    automuting Boolean
    Configuration to enable/disable auto-muting flag
    logRules Property Map
    Set of rules for sending logs for the Monitor resource.
    metricRules Property Map
    Set of rules for sending metrics for the Monitor resource.

    MonitoringTagRulesPropertiesResponse, MonitoringTagRulesPropertiesResponseArgs

    ProvisioningState string
    Automuting bool
    Configuration to enable/disable auto-muting flag
    LogRules Pulumi.AzureNative.Datadog.Inputs.LogRulesResponse
    Set of rules for sending logs for the Monitor resource.
    MetricRules Pulumi.AzureNative.Datadog.Inputs.MetricRulesResponse
    Set of rules for sending metrics for the Monitor resource.
    ProvisioningState string
    Automuting bool
    Configuration to enable/disable auto-muting flag
    LogRules LogRulesResponse
    Set of rules for sending logs for the Monitor resource.
    MetricRules MetricRulesResponse
    Set of rules for sending metrics for the Monitor resource.
    provisioningState String
    automuting Boolean
    Configuration to enable/disable auto-muting flag
    logRules LogRulesResponse
    Set of rules for sending logs for the Monitor resource.
    metricRules MetricRulesResponse
    Set of rules for sending metrics for the Monitor resource.
    provisioningState string
    automuting boolean
    Configuration to enable/disable auto-muting flag
    logRules LogRulesResponse
    Set of rules for sending logs for the Monitor resource.
    metricRules MetricRulesResponse
    Set of rules for sending metrics for the Monitor resource.
    provisioning_state str
    automuting bool
    Configuration to enable/disable auto-muting flag
    log_rules LogRulesResponse
    Set of rules for sending logs for the Monitor resource.
    metric_rules MetricRulesResponse
    Set of rules for sending metrics for the Monitor resource.
    provisioningState String
    automuting Boolean
    Configuration to enable/disable auto-muting flag
    logRules Property Map
    Set of rules for sending logs for the Monitor resource.
    metricRules Property Map
    Set of rules for sending metrics for the Monitor resource.

    Operation, OperationArgs

    AddBegin
    AddBegin
    AddComplete
    AddComplete
    DeleteBegin
    DeleteBegin
    DeleteComplete
    DeleteComplete
    Active
    Active
    OperationAddBegin
    AddBegin
    OperationAddComplete
    AddComplete
    OperationDeleteBegin
    DeleteBegin
    OperationDeleteComplete
    DeleteComplete
    OperationActive
    Active
    AddBegin
    AddBegin
    AddComplete
    AddComplete
    DeleteBegin
    DeleteBegin
    DeleteComplete
    DeleteComplete
    Active
    Active
    AddBegin
    AddBegin
    AddComplete
    AddComplete
    DeleteBegin
    DeleteBegin
    DeleteComplete
    DeleteComplete
    Active
    Active
    ADD_BEGIN
    AddBegin
    ADD_COMPLETE
    AddComplete
    DELETE_BEGIN
    DeleteBegin
    DELETE_COMPLETE
    DeleteComplete
    ACTIVE
    Active
    "AddBegin"
    AddBegin
    "AddComplete"
    AddComplete
    "DeleteBegin"
    DeleteBegin
    "DeleteComplete"
    DeleteComplete
    "Active"
    Active

    Status, StatusArgs

    InProgress
    InProgress
    Active
    Active
    Failed
    Failed
    Deleting
    Deleting
    StatusInProgress
    InProgress
    StatusActive
    Active
    StatusFailed
    Failed
    StatusDeleting
    Deleting
    InProgress
    InProgress
    Active
    Active
    Failed
    Failed
    Deleting
    Deleting
    InProgress
    InProgress
    Active
    Active
    Failed
    Failed
    Deleting
    Deleting
    IN_PROGRESS
    InProgress
    ACTIVE
    Active
    FAILED
    Failed
    DELETING
    Deleting
    "InProgress"
    InProgress
    "Active"
    Active
    "Failed"
    Failed
    "Deleting"
    Deleting

    SubscriptionList, SubscriptionListArgs

    MonitoredSubscriptionList List<Pulumi.AzureNative.Datadog.Inputs.MonitoredSubscription>
    List of subscriptions and the state of the monitoring.
    Operation string | Pulumi.AzureNative.Datadog.Operation
    The operation for the patch on the resource.
    MonitoredSubscriptionList []MonitoredSubscriptionType
    List of subscriptions and the state of the monitoring.
    Operation string | Operation
    The operation for the patch on the resource.
    monitoredSubscriptionList List<MonitoredSubscription>
    List of subscriptions and the state of the monitoring.
    operation String | Operation
    The operation for the patch on the resource.
    monitoredSubscriptionList MonitoredSubscription[]
    List of subscriptions and the state of the monitoring.
    operation string | Operation
    The operation for the patch on the resource.
    monitored_subscription_list Sequence[MonitoredSubscription]
    List of subscriptions and the state of the monitoring.
    operation str | Operation
    The operation for the patch on the resource.
    monitoredSubscriptionList List<Property Map>
    List of subscriptions and the state of the monitoring.
    operation String | "AddBegin" | "AddComplete" | "DeleteBegin" | "DeleteComplete" | "Active"
    The operation for the patch on the resource.

    SubscriptionListResponse, SubscriptionListResponseArgs

    MonitoredSubscriptionList []MonitoredSubscriptionResponse
    List of subscriptions and the state of the monitoring.
    monitoredSubscriptionList List<MonitoredSubscriptionResponse>
    List of subscriptions and the state of the monitoring.
    monitoredSubscriptionList MonitoredSubscriptionResponse[]
    List of subscriptions and the state of the monitoring.
    monitored_subscription_list Sequence[MonitoredSubscriptionResponse]
    List of subscriptions and the state of the monitoring.
    monitoredSubscriptionList List<Property Map>
    List of subscriptions and the state of the monitoring.

    TagAction, TagActionArgs

    Include
    Include
    Exclude
    Exclude
    TagActionInclude
    Include
    TagActionExclude
    Exclude
    Include
    Include
    Exclude
    Exclude
    Include
    Include
    Exclude
    Exclude
    INCLUDE
    Include
    EXCLUDE
    Exclude
    "Include"
    Include
    "Exclude"
    Exclude

    Import

    An existing resource can be imported using its type token, name, and identifier, e.g.

    $ pulumi import azure-native:datadog:MonitoredSubscription default /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Datadog/monitors/{monitorName}/monitoredSubscriptions/{configurationName}

    To learn more about importing existing cloud resources, see Importing resources.

    Package Details

    Repository
    Azure Native pulumi/pulumi-azure-native
    License
    Apache-2.0
    azure-native logo
    This is the latest version of Azure Native. Use the Azure Native v1 docs if using the v1 version of this package.
    Azure Native v2.73.0 published on Wednesday, Nov 20, 2024 by Pulumi
    pulumi/pulumi-azure-native