azure-native.app.ConnectedEnvironmentsDaprComponent

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

return await Deployment.RunAsync(() => 
{
    var connectedEnvironmentsDaprComponent = new AzureNative.App.ConnectedEnvironmentsDaprComponent("connectedEnvironmentsDaprComponent", new()
    {
        ComponentName = "reddog",
        ComponentType = "state.azure.cosmosdb",
        ConnectedEnvironmentName = "myenvironment",
        IgnoreErrors = false,
        InitTimeout = "50s",
        Metadata = new[]
        {
            new AzureNative.App.Inputs.DaprMetadataArgs
            {
                Name = "url",
                Value = "<COSMOS-URL>",
            },
            new AzureNative.App.Inputs.DaprMetadataArgs
            {
                Name = "database",
                Value = "itemsDB",
            },
            new AzureNative.App.Inputs.DaprMetadataArgs
            {
                Name = "collection",
                Value = "items",
            },
            new AzureNative.App.Inputs.DaprMetadataArgs
            {
                Name = "masterkey",
                SecretRef = "masterkey",
            },
        },
        ResourceGroupName = "examplerg",
        Scopes = new[]
        {
            "container-app-1",
            "container-app-2",
        },
        Secrets = new[]
        {
            new AzureNative.App.Inputs.SecretArgs
            {
                Name = "masterkey",
                Value = "keyvalue",
            },
        },
        Version = "v1",
    });

});

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := app.NewConnectedEnvironmentsDaprComponent(ctx, "connectedEnvironmentsDaprComponent", &app.ConnectedEnvironmentsDaprComponentArgs{
			ComponentName:            pulumi.String("reddog"),
			ComponentType:            pulumi.String("state.azure.cosmosdb"),
			ConnectedEnvironmentName: pulumi.String("myenvironment"),
			IgnoreErrors:             pulumi.Bool(false),
			InitTimeout:              pulumi.String("50s"),
			Metadata: app.DaprMetadataArray{
				&app.DaprMetadataArgs{
					Name:  pulumi.String("url"),
					Value: pulumi.String("<COSMOS-URL>"),
				},
				&app.DaprMetadataArgs{
					Name:  pulumi.String("database"),
					Value: pulumi.String("itemsDB"),
				},
				&app.DaprMetadataArgs{
					Name:  pulumi.String("collection"),
					Value: pulumi.String("items"),
				},
				&app.DaprMetadataArgs{
					Name:      pulumi.String("masterkey"),
					SecretRef: pulumi.String("masterkey"),
				},
			},
			ResourceGroupName: pulumi.String("examplerg"),
			Scopes: pulumi.StringArray{
				pulumi.String("container-app-1"),
				pulumi.String("container-app-2"),
			},
			Secrets: app.SecretArray{
				&app.SecretArgs{
					Name:  pulumi.String("masterkey"),
					Value: pulumi.String("keyvalue"),
				},
			},
			Version: pulumi.String("v1"),
		})
		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.app.ConnectedEnvironmentsDaprComponent;
import com.pulumi.azurenative.app.ConnectedEnvironmentsDaprComponentArgs;
import com.pulumi.azurenative.app.inputs.DaprMetadataArgs;
import com.pulumi.azurenative.app.inputs.SecretArgs;
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 connectedEnvironmentsDaprComponent = new ConnectedEnvironmentsDaprComponent("connectedEnvironmentsDaprComponent", ConnectedEnvironmentsDaprComponentArgs.builder()
            .componentName("reddog")
            .componentType("state.azure.cosmosdb")
            .connectedEnvironmentName("myenvironment")
            .ignoreErrors(false)
            .initTimeout("50s")
            .metadata(            
                DaprMetadataArgs.builder()
                    .name("url")
                    .value("<COSMOS-URL>")
                    .build(),
                DaprMetadataArgs.builder()
                    .name("database")
                    .value("itemsDB")
                    .build(),
                DaprMetadataArgs.builder()
                    .name("collection")
                    .value("items")
                    .build(),
                DaprMetadataArgs.builder()
                    .name("masterkey")
                    .secretRef("masterkey")
                    .build())
            .resourceGroupName("examplerg")
            .scopes(            
                "container-app-1",
                "container-app-2")
            .secrets(SecretArgs.builder()
                .name("masterkey")
                .value("keyvalue")
                .build())
            .version("v1")
            .build());

    }
}

import pulumi
import pulumi_azure_native as azure_native

connected_environments_dapr_component = azure_native.app.ConnectedEnvironmentsDaprComponent("connectedEnvironmentsDaprComponent",
    component_name="reddog",
    component_type="state.azure.cosmosdb",
    connected_environment_name="myenvironment",
    ignore_errors=False,
    init_timeout="50s",
    metadata=[
        {
            "name": "url",
            "value": "<COSMOS-URL>",
        },
        {
            "name": "database",
            "value": "itemsDB",
        },
        {
            "name": "collection",
            "value": "items",
        },
        {
            "name": "masterkey",
            "secret_ref": "masterkey",
        },
    ],
    resource_group_name="examplerg",
    scopes=[
        "container-app-1",
        "container-app-2",
    ],
    secrets=[{
        "name": "masterkey",
        "value": "keyvalue",
    }],
    version="v1")

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

const connectedEnvironmentsDaprComponent = new azure_native.app.ConnectedEnvironmentsDaprComponent("connectedEnvironmentsDaprComponent", {
    componentName: "reddog",
    componentType: "state.azure.cosmosdb",
    connectedEnvironmentName: "myenvironment",
    ignoreErrors: false,
    initTimeout: "50s",
    metadata: [
        {
            name: "url",
            value: "<COSMOS-URL>",
        },
        {
            name: "database",
            value: "itemsDB",
        },
        {
            name: "collection",
            value: "items",
        },
        {
            name: "masterkey",
            secretRef: "masterkey",
        },
    ],
    resourceGroupName: "examplerg",
    scopes: [
        "container-app-1",
        "container-app-2",
    ],
    secrets: [{
        name: "masterkey",
        value: "keyvalue",
    }],
    version: "v1",
});

resources:
  connectedEnvironmentsDaprComponent:
    type: azure-native:app:ConnectedEnvironmentsDaprComponent
    properties:
      componentName: reddog
      componentType: state.azure.cosmosdb
      connectedEnvironmentName: myenvironment
      ignoreErrors: false
      initTimeout: 50s
      metadata:
        - name: url
          value: <COSMOS-URL>
        - name: database
          value: itemsDB
        - name: collection
          value: items
        - name: masterkey
          secretRef: masterkey
      resourceGroupName: examplerg
      scopes:
        - container-app-1
        - container-app-2
      secrets:
        - name: masterkey
          value: keyvalue
      version: v1