Account

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azure.core.ResourceGroup;
import com.pulumi.azure.core.ResourceGroupArgs;
import com.pulumi.random.RandomInteger;
import com.pulumi.random.RandomIntegerArgs;
import com.pulumi.azure.cosmosdb.Account;
import com.pulumi.azure.cosmosdb.AccountArgs;
import com.pulumi.azure.cosmosdb.inputs.AccountCapabilityArgs;
import com.pulumi.azure.cosmosdb.inputs.AccountConsistencyPolicyArgs;
import com.pulumi.azure.cosmosdb.inputs.AccountGeoLocationArgs;
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 rg = new ResourceGroup("rg", ResourceGroupArgs.builder()
            .name("sample-rg")
            .location("westus")
            .build());
        var ri = new RandomInteger("ri", RandomIntegerArgs.builder()
            .min(10000)
            .max(99999)
            .build());
        var db = new Account("db", AccountArgs.builder()
            .name(ri.result().applyValue(result -> String.format("tfex-cosmos-db-%s", result)))
            .location(example.location())
            .resourceGroupName(example.name())
            .offerType("Standard")
            .kind("MongoDB")
            .enableAutomaticFailover(true)
            .capabilities(
                AccountCapabilityArgs.builder()
                    .name("EnableAggregationPipeline")
                    .build(),
                AccountCapabilityArgs.builder()
                    .name("mongoEnableDocLevelTTL")
                    .build(),
                AccountCapabilityArgs.builder()
                    .name("MongoDBv3.4")
                    .build(),
                AccountCapabilityArgs.builder()
                    .name("EnableMongo")
                    .build())
            .consistencyPolicy(AccountConsistencyPolicyArgs.builder()
                .consistencyLevel("BoundedStaleness")
                .maxIntervalInSeconds(300)
                .maxStalenessPrefix(100000)
                .build())
            .geoLocations(
                AccountGeoLocationArgs.builder()
                    .location("eastus")
                    .failoverPriority(1)
                    .build(),
                AccountGeoLocationArgs.builder()
                    .location("westus")
                    .failoverPriority(0)
                    .build())
            .build());
    }
}

import * as pulumi from "@pulumi/pulumi";
import * as azure from "@pulumi/azure";
import * as std from "@pulumi/std";
const example = new azure.authorization.UserAssignedIdentity("example", {
    resourceGroupName: exampleAzurermResourceGroup.name,
    location: exampleAzurermResourceGroup.location,
    name: "example-resource",
});
const exampleAccount = new azure.cosmosdb.Account("example", {
    name: "example-resource",
    location: exampleAzurermResourceGroup.location,
    resourceGroupName: exampleAzurermResourceGroup.name,
    defaultIdentityType: std.joinOutput({
        separator: "=",
        input: [
            "UserAssignedIdentity",
            example.id,
        ],
    }).apply(invoke => invoke.result),
    offerType: "Standard",
    kind: "MongoDB",
    capabilities: [{
        name: "EnableMongo",
    }],
    consistencyPolicy: {
        consistencyLevel: "Strong",
    },
    geoLocations: [{
        location: "westus",
        failoverPriority: 0,
    }],
    identity: {
        type: "UserAssigned",
        identityIds: [example.id],
    },
});

import pulumi
import pulumi_azure as azure
import pulumi_std as std
example = azure.authorization.UserAssignedIdentity("example",
    resource_group_name=example_azurerm_resource_group["name"],
    location=example_azurerm_resource_group["location"],
    name="example-resource")
example_account = azure.cosmosdb.Account("example",
    name="example-resource",
    location=example_azurerm_resource_group["location"],
    resource_group_name=example_azurerm_resource_group["name"],
    default_identity_type=std.join_output(separator="=",
        input=[
            "UserAssignedIdentity",
            example.id,
        ]).apply(lambda invoke: invoke.result),
    offer_type="Standard",
    kind="MongoDB",
    capabilities=[azure.cosmosdb.AccountCapabilityArgs(
        name="EnableMongo",
    )],
    consistency_policy=azure.cosmosdb.AccountConsistencyPolicyArgs(
        consistency_level="Strong",
    ),
    geo_locations=[azure.cosmosdb.AccountGeoLocationArgs(
        location="westus",
        failover_priority=0,
    )],
    identity=azure.cosmosdb.AccountIdentityArgs(
        type="UserAssigned",
        identity_ids=[example.id],
    ))

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Azure = Pulumi.Azure;
using Std = Pulumi.Std;
return await Deployment.RunAsync(() =>
{
    var example = new Azure.Authorization.UserAssignedIdentity("example", new()
    {
        ResourceGroupName = exampleAzurermResourceGroup.Name,
        Location = exampleAzurermResourceGroup.Location,
        Name = "example-resource",
    });
    var exampleAccount = new Azure.CosmosDB.Account("example", new()
    {
        Name = "example-resource",
        Location = exampleAzurermResourceGroup.Location,
        ResourceGroupName = exampleAzurermResourceGroup.Name,
        DefaultIdentityType = Std.Join.Invoke(new()
        {
            Separator = "=",
            Input = new[]
            {
                "UserAssignedIdentity",
                example.Id,
            },
        }).Apply(invoke => invoke.Result),
        OfferType = "Standard",
        Kind = "MongoDB",
        Capabilities = new[]
        {
            new Azure.CosmosDB.Inputs.AccountCapabilityArgs
            {
                Name = "EnableMongo",
            },
        },
        ConsistencyPolicy = new Azure.CosmosDB.Inputs.AccountConsistencyPolicyArgs
        {
            ConsistencyLevel = "Strong",
        },
        GeoLocations = new[]
        {
            new Azure.CosmosDB.Inputs.AccountGeoLocationArgs
            {
                Location = "westus",
                FailoverPriority = 0,
            },
        },
        Identity = new Azure.CosmosDB.Inputs.AccountIdentityArgs
        {
            Type = "UserAssigned",
            IdentityIds = new[]
            {
                example.Id,
            },
        },
    });
});

package main
import (
	"github.com/pulumi/pulumi-azure/sdk/v5/go/azure/authorization"
	"github.com/pulumi/pulumi-azure/sdk/v5/go/azure/cosmosdb"
	"github.com/pulumi/pulumi-std/sdk/go/std"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := authorization.NewUserAssignedIdentity(ctx, "example", &authorization.UserAssignedIdentityArgs{
			ResourceGroupName: pulumi.Any(exampleAzurermResourceGroup.Name),
			Location:          pulumi.Any(exampleAzurermResourceGroup.Location),
			Name:              pulumi.String("example-resource"),
		})
		if err != nil {
			return err
		}
		_, err = cosmosdb.NewAccount(ctx, "example", &cosmosdb.AccountArgs{
			Name:              pulumi.String("example-resource"),
			Location:          pulumi.Any(exampleAzurermResourceGroup.Location),
			ResourceGroupName: pulumi.Any(exampleAzurermResourceGroup.Name),
			DefaultIdentityType: std.JoinOutput(ctx, std.JoinOutputArgs{
				Separator: pulumi.String("="),
				Input: pulumi.StringArray{
					pulumi.String("UserAssignedIdentity"),
					example.ID(),
				},
			}, nil).ApplyT(func(invoke std.JoinResult) (*string, error) {
				return invoke.Result, nil
			}).(pulumi.StringPtrOutput),
			OfferType: pulumi.String("Standard"),
			Kind:      pulumi.String("MongoDB"),
			Capabilities: cosmosdb.AccountCapabilityArray{
				&cosmosdb.AccountCapabilityArgs{
					Name: pulumi.String("EnableMongo"),
				},
			},
			ConsistencyPolicy: &cosmosdb.AccountConsistencyPolicyArgs{
				ConsistencyLevel: pulumi.String("Strong"),
			},
			GeoLocations: cosmosdb.AccountGeoLocationArray{
				&cosmosdb.AccountGeoLocationArgs{
					Location:         pulumi.String("westus"),
					FailoverPriority: pulumi.Int(0),
				},
			},
			Identity: &cosmosdb.AccountIdentityArgs{
				Type: pulumi.String("UserAssigned"),
				IdentityIds: pulumi.StringArray{
					example.ID(),
				},
			},
		})
		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.azure.authorization.UserAssignedIdentity;
import com.pulumi.azure.authorization.UserAssignedIdentityArgs;
import com.pulumi.azure.cosmosdb.Account;
import com.pulumi.azure.cosmosdb.AccountArgs;
import com.pulumi.azure.cosmosdb.inputs.AccountCapabilityArgs;
import com.pulumi.azure.cosmosdb.inputs.AccountConsistencyPolicyArgs;
import com.pulumi.azure.cosmosdb.inputs.AccountGeoLocationArgs;
import com.pulumi.azure.cosmosdb.inputs.AccountIdentityArgs;
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 example = new UserAssignedIdentity("example", UserAssignedIdentityArgs.builder()
            .resourceGroupName(exampleAzurermResourceGroup.name())
            .location(exampleAzurermResourceGroup.location())
            .name("example-resource")
            .build());
        var exampleAccount = new Account("exampleAccount", AccountArgs.builder()
            .name("example-resource")
            .location(exampleAzurermResourceGroup.location())
            .resourceGroupName(exampleAzurermResourceGroup.name())
            .defaultIdentityType(StdFunctions.join().applyValue(invoke -> invoke.result()))
            .offerType("Standard")
            .kind("MongoDB")
            .capabilities(AccountCapabilityArgs.builder()
                .name("EnableMongo")
                .build())
            .consistencyPolicy(AccountConsistencyPolicyArgs.builder()
                .consistencyLevel("Strong")
                .build())
            .geoLocations(AccountGeoLocationArgs.builder()
                .location("westus")
                .failoverPriority(0)
                .build())
            .identity(AccountIdentityArgs.builder()
                .type("UserAssigned")
                .identityIds(example.id())
                .build())
            .build());
    }
}

resources:
  example:
    type: azure:authorization:UserAssignedIdentity
    properties:
      resourceGroupName: ${exampleAzurermResourceGroup.name}
      location: ${exampleAzurermResourceGroup.location}
      name: example-resource
  exampleAccount:
    type: azure:cosmosdb:Account
    name: example
    properties:
      name: example-resource
      location: ${exampleAzurermResourceGroup.location}
      resourceGroupName: ${exampleAzurermResourceGroup.name}
      defaultIdentityType:
        fn::invoke:
          Function: std:join
          Arguments:
            separator: =
            input:
              - UserAssignedIdentity
              - ${example.id}
          Return: result
      offerType: Standard
      kind: MongoDB
      capabilities:
        - name: EnableMongo
      consistencyPolicy:
        consistencyLevel: Strong
      geoLocations:
        - location: westus
          failoverPriority: 0
      identity:
        type: UserAssigned
        identityIds:
          - ${example.id}

$ pulumi import azure:cosmosdb/account:Account account1 /subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.DocumentDB/databaseAccounts/account1