grafana.cloudProvider.getAzureCredential

import * as pulumi from "@pulumi/pulumi";
import * as grafana from "@pulumiverse/grafana";

const testAzureCredential = new grafana.cloudprovider.AzureCredential("test", {
    stackId: "1",
    name: "test-name",
    clientId: "my-client-id",
    clientSecret: "my-client-secret",
    tenantId: "my-tenant-id",
    resourceTagsToAddToMetrics: [
        "tag1",
        "tag2",
    ],
    resourceDiscoveryTagFilters: [
        {
            key: "key-1",
            value: "value-1",
        },
        {
            key: "key-2",
            value: "value-2",
        },
    ],
    autoDiscoveryConfigurations: [{
        subscriptionId: "my-subscription_id",
        resourceTypeConfigurations: [
            {
                resourceTypeName: "Microsoft.App/containerApps",
                metricConfiguration: [{
                    name: "TotalCoresQuotaUsed",
                }],
            },
            {
                resourceTypeName: "Microsoft.Storage/storageAccounts/tableServices",
                metricConfiguration: [{
                    name: "Availability",
                    dimensions: [
                        "GeoType",
                        "ApiName",
                    ],
                    aggregations: ["Average"],
                }],
            },
        ],
    }],
});
const test = grafana.cloudProvider.getAzureCredentialOutput({
    stackId: testAzureCredential.stackId,
    resourceId: testAzureCredential.resourceId,
});

import pulumi
import pulumi_grafana as grafana
import pulumiverse_grafana as grafana

test_azure_credential = grafana.cloudprovider.AzureCredential("test",
    stack_id="1",
    name="test-name",
    client_id="my-client-id",
    client_secret="my-client-secret",
    tenant_id="my-tenant-id",
    resource_tags_to_add_to_metrics=[
        "tag1",
        "tag2",
    ],
    resource_discovery_tag_filters=[
        {
            "key": "key-1",
            "value": "value-1",
        },
        {
            "key": "key-2",
            "value": "value-2",
        },
    ],
    auto_discovery_configurations=[{
        "subscription_id": "my-subscription_id",
        "resource_type_configurations": [
            {
                "resource_type_name": "Microsoft.App/containerApps",
                "metric_configuration": [{
                    "name": "TotalCoresQuotaUsed",
                }],
            },
            {
                "resource_type_name": "Microsoft.Storage/storageAccounts/tableServices",
                "metric_configuration": [{
                    "name": "Availability",
                    "dimensions": [
                        "GeoType",
                        "ApiName",
                    ],
                    "aggregations": ["Average"],
                }],
            },
        ],
    }])
test = grafana.cloudProvider.get_azure_credential_output(stack_id=test_azure_credential.stack_id,
    resource_id=test_azure_credential.resource_id)

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumiverse/pulumi-grafana/sdk/v2/go/grafana/cloudprovider"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		testAzureCredential, err := cloudprovider.NewAzureCredential(ctx, "test", &cloudprovider.AzureCredentialArgs{
			StackId:      pulumi.String("1"),
			Name:         pulumi.String("test-name"),
			ClientId:     pulumi.String("my-client-id"),
			ClientSecret: pulumi.String("my-client-secret"),
			TenantId:     pulumi.String("my-tenant-id"),
			ResourceTagsToAddToMetrics: pulumi.StringArray{
				pulumi.String("tag1"),
				pulumi.String("tag2"),
			},
			ResourceDiscoveryTagFilters: cloudprovider.AzureCredentialResourceDiscoveryTagFilterArray{
				&cloudprovider.AzureCredentialResourceDiscoveryTagFilterArgs{
					Key:   pulumi.String("key-1"),
					Value: pulumi.String("value-1"),
				},
				&cloudprovider.AzureCredentialResourceDiscoveryTagFilterArgs{
					Key:   pulumi.String("key-2"),
					Value: pulumi.String("value-2"),
				},
			},
			AutoDiscoveryConfigurations: cloudprovider.AzureCredentialAutoDiscoveryConfigurationArray{
				&cloudprovider.AzureCredentialAutoDiscoveryConfigurationArgs{
					SubscriptionId: pulumi.String("my-subscription_id"),
					ResourceTypeConfigurations: cloudprovider.AzureCredentialAutoDiscoveryConfigurationResourceTypeConfigurationArray{
						&cloudprovider.AzureCredentialAutoDiscoveryConfigurationResourceTypeConfigurationArgs{
							ResourceTypeName: pulumi.String("Microsoft.App/containerApps"),
							MetricConfiguration: []map[string]interface{}{
								map[string]interface{}{
									"name": "TotalCoresQuotaUsed",
								},
							},
						},
						&cloudprovider.AzureCredentialAutoDiscoveryConfigurationResourceTypeConfigurationArgs{
							ResourceTypeName: pulumi.String("Microsoft.Storage/storageAccounts/tableServices"),
							MetricConfiguration: []map[string]interface{}{
								map[string]interface{}{
									"name": "Availability",
									"dimensions": []string{
										"GeoType",
										"ApiName",
									},
									"aggregations": []string{
										"Average",
									},
								},
							},
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		_ = cloudprovider.GetAzureCredentialOutput(ctx, cloudprovider.GetAzureCredentialOutputArgs{
			StackId:    testAzureCredential.StackId,
			ResourceId: testAzureCredential.ResourceId,
		}, nil)
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Grafana = Pulumi.Grafana;
using Grafana = Pulumiverse.Grafana;

return await Deployment.RunAsync(() => 
{
    var testAzureCredential = new Grafana.CloudProvider.AzureCredential("test", new()
    {
        StackId = "1",
        Name = "test-name",
        ClientId = "my-client-id",
        ClientSecret = "my-client-secret",
        TenantId = "my-tenant-id",
        ResourceTagsToAddToMetrics = new[]
        {
            "tag1",
            "tag2",
        },
        ResourceDiscoveryTagFilters = new[]
        {
            new Grafana.CloudProvider.Inputs.AzureCredentialResourceDiscoveryTagFilterArgs
            {
                Key = "key-1",
                Value = "value-1",
            },
            new Grafana.CloudProvider.Inputs.AzureCredentialResourceDiscoveryTagFilterArgs
            {
                Key = "key-2",
                Value = "value-2",
            },
        },
        AutoDiscoveryConfigurations = new[]
        {
            new Grafana.CloudProvider.Inputs.AzureCredentialAutoDiscoveryConfigurationArgs
            {
                SubscriptionId = "my-subscription_id",
                ResourceTypeConfigurations = new[]
                {
                    new Grafana.CloudProvider.Inputs.AzureCredentialAutoDiscoveryConfigurationResourceTypeConfigurationArgs
                    {
                        ResourceTypeName = "Microsoft.App/containerApps",
                        MetricConfiguration = new[]
                        {
                            
                            {
                                { "name", "TotalCoresQuotaUsed" },
                            },
                        },
                    },
                    new Grafana.CloudProvider.Inputs.AzureCredentialAutoDiscoveryConfigurationResourceTypeConfigurationArgs
                    {
                        ResourceTypeName = "Microsoft.Storage/storageAccounts/tableServices",
                        MetricConfiguration = new[]
                        {
                            
                            {
                                { "name", "Availability" },
                                { "dimensions", new[]
                                {
                                    "GeoType",
                                    "ApiName",
                                } },
                                { "aggregations", new[]
                                {
                                    "Average",
                                } },
                            },
                        },
                    },
                },
            },
        },
    });

    var test = Grafana.CloudProvider.GetAzureCredential.Invoke(new()
    {
        StackId = testAzureCredential.StackId,
        ResourceId = testAzureCredential.ResourceId,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.grafana.cloudProvider.AzureCredential;
import com.pulumi.grafana.cloudProvider.AzureCredentialArgs;
import com.pulumi.grafana.cloudProvider.inputs.AzureCredentialResourceDiscoveryTagFilterArgs;
import com.pulumi.grafana.cloudProvider.inputs.AzureCredentialAutoDiscoveryConfigurationArgs;
import com.pulumi.grafana.cloudProvider.CloudProviderFunctions;
import com.pulumi.grafana.cloudProvider.inputs.GetAzureCredentialArgs;
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 testAzureCredential = new AzureCredential("testAzureCredential", AzureCredentialArgs.builder()
            .stackId("1")
            .name("test-name")
            .clientId("my-client-id")
            .clientSecret("my-client-secret")
            .tenantId("my-tenant-id")
            .resourceTagsToAddToMetrics(            
                "tag1",
                "tag2")
            .resourceDiscoveryTagFilters(            
                AzureCredentialResourceDiscoveryTagFilterArgs.builder()
                    .key("key-1")
                    .value("value-1")
                    .build(),
                AzureCredentialResourceDiscoveryTagFilterArgs.builder()
                    .key("key-2")
                    .value("value-2")
                    .build())
            .autoDiscoveryConfigurations(AzureCredentialAutoDiscoveryConfigurationArgs.builder()
                .subscriptionId("my-subscription_id")
                .resourceTypeConfigurations(                
                    AzureCredentialAutoDiscoveryConfigurationResourceTypeConfigurationArgs.builder()
                        .resourceTypeName("Microsoft.App/containerApps")
                        .metricConfiguration(List.of(Map.of("name", "TotalCoresQuotaUsed")))
                        .build(),
                    AzureCredentialAutoDiscoveryConfigurationResourceTypeConfigurationArgs.builder()
                        .resourceTypeName("Microsoft.Storage/storageAccounts/tableServices")
                        .metricConfiguration(List.of(Map.ofEntries(
                            Map.entry("name", "Availability"),
                            Map.entry("dimensions", List.of(                            
                                "GeoType",
                                "ApiName")),
                            Map.entry("aggregations", List.of("Average"))
                        )))
                        .build())
                .build())
            .build());

        final var test = CloudProviderFunctions.getAzureCredential(GetAzureCredentialArgs.builder()
            .stackId(testAzureCredential.stackId())
            .resourceId(testAzureCredential.resourceId())
            .build());

    }
}

resources:
  testAzureCredential:
    type: grafana:cloudProvider:AzureCredential
    name: test
    properties:
      stackId: '1'
      name: test-name
      clientId: my-client-id
      clientSecret: my-client-secret
      tenantId: my-tenant-id
      resourceTagsToAddToMetrics:
        - tag1
        - tag2
      resourceDiscoveryTagFilters:
        - key: key-1
          value: value-1
        - key: key-2
          value: value-2
      autoDiscoveryConfigurations:
        - subscriptionId: my-subscription_id
          resourceTypeConfigurations:
            - resourceTypeName: Microsoft.App/containerApps
              metricConfiguration:
                - name: TotalCoresQuotaUsed
            - resourceTypeName: Microsoft.Storage/storageAccounts/tableServices
              metricConfiguration:
                - name: Availability
                  dimensions:
                    - GeoType
                    - ApiName
                  aggregations:
                    - Average
variables:
  test:
    fn::invoke:
      function: grafana:cloudProvider:getAzureCredential
      arguments:
        stackId: ${testAzureCredential.stackId}
        resourceId: ${testAzureCredential.resourceId}

function getAzureCredential(args: GetAzureCredentialArgs, opts?: InvokeOptions): Promise<GetAzureCredentialResult>
function getAzureCredentialOutput(args: GetAzureCredentialOutputArgs, opts?: InvokeOptions): Output<GetAzureCredentialResult>

def get_azure_credential(auto_discovery_configurations: Optional[Sequence[GetAzureCredentialAutoDiscoveryConfiguration]] = None,
                         resource_discovery_tag_filters: Optional[Sequence[GetAzureCredentialResourceDiscoveryTagFilter]] = None,
                         resource_id: Optional[str] = None,
                         stack_id: Optional[str] = None,
                         opts: Optional[InvokeOptions] = None) -> GetAzureCredentialResult
def get_azure_credential_output(auto_discovery_configurations: Optional[pulumi.Input[Sequence[pulumi.Input[GetAzureCredentialAutoDiscoveryConfigurationArgs]]]] = None,
                         resource_discovery_tag_filters: Optional[pulumi.Input[Sequence[pulumi.Input[GetAzureCredentialResourceDiscoveryTagFilterArgs]]]] = None,
                         resource_id: Optional[pulumi.Input[str]] = None,
                         stack_id: Optional[pulumi.Input[str]] = None,
                         opts: Optional[InvokeOptions] = None) -> Output[GetAzureCredentialResult]

func LookupAzureCredential(ctx *Context, args *LookupAzureCredentialArgs, opts ...InvokeOption) (*LookupAzureCredentialResult, error)
func LookupAzureCredentialOutput(ctx *Context, args *LookupAzureCredentialOutputArgs, opts ...InvokeOption) LookupAzureCredentialResultOutput

public static class GetAzureCredential 
{
    public static Task<GetAzureCredentialResult> InvokeAsync(GetAzureCredentialArgs args, InvokeOptions? opts = null)
    public static Output<GetAzureCredentialResult> Invoke(GetAzureCredentialInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetAzureCredentialResult> getAzureCredential(GetAzureCredentialArgs args, InvokeOptions options)
public static Output<GetAzureCredentialResult> getAzureCredential(GetAzureCredentialArgs args, InvokeOptions options)

fn::invoke:
  function: grafana:cloudProvider/getAzureCredential:getAzureCredential
  arguments:
    # arguments dictionary