azure.cosmosdb.CassandraCluster

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Azure = Pulumi.Azure;
using AzureAD = Pulumi.AzureAD;

return await Deployment.RunAsync(() => 
{
    var exampleResourceGroup = new Azure.Core.ResourceGroup("exampleResourceGroup", new()
    {
        Location = "West Europe",
    });

    var exampleVirtualNetwork = new Azure.Network.VirtualNetwork("exampleVirtualNetwork", new()
    {
        Location = exampleResourceGroup.Location,
        ResourceGroupName = exampleResourceGroup.Name,
        AddressSpaces = new[]
        {
            "10.0.0.0/16",
        },
    });

    var exampleSubnet = new Azure.Network.Subnet("exampleSubnet", new()
    {
        ResourceGroupName = exampleResourceGroup.Name,
        VirtualNetworkName = exampleVirtualNetwork.Name,
        AddressPrefixes = new[]
        {
            "10.0.1.0/24",
        },
    });

    var exampleServicePrincipal = AzureAD.GetServicePrincipal.Invoke(new()
    {
        DisplayName = "Azure Cosmos DB",
    });

    var exampleAssignment = new Azure.Authorization.Assignment("exampleAssignment", new()
    {
        Scope = exampleVirtualNetwork.Id,
        RoleDefinitionName = "Network Contributor",
        PrincipalId = exampleServicePrincipal.Apply(getServicePrincipalResult => getServicePrincipalResult.ObjectId),
    });

    var exampleCassandraCluster = new Azure.CosmosDB.CassandraCluster("exampleCassandraCluster", new()
    {
        ResourceGroupName = exampleResourceGroup.Name,
        Location = exampleResourceGroup.Location,
        DelegatedManagementSubnetId = exampleSubnet.Id,
        DefaultAdminPassword = "Password1234",
    }, new CustomResourceOptions
    {
        DependsOn = new[]
        {
            exampleAssignment,
        },
    });

});

package main

import (
	"github.com/pulumi/pulumi-azure/sdk/v5/go/azure/authorization"
	"github.com/pulumi/pulumi-azure/sdk/v5/go/azure/core"
	"github.com/pulumi/pulumi-azure/sdk/v5/go/azure/cosmosdb"
	"github.com/pulumi/pulumi-azure/sdk/v5/go/azure/network"
	"github.com/pulumi/pulumi-azuread/sdk/v5/go/azuread"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleResourceGroup, err := core.NewResourceGroup(ctx, "exampleResourceGroup", &core.ResourceGroupArgs{
			Location: pulumi.String("West Europe"),
		})
		if err != nil {
			return err
		}
		exampleVirtualNetwork, err := network.NewVirtualNetwork(ctx, "exampleVirtualNetwork", &network.VirtualNetworkArgs{
			Location:          exampleResourceGroup.Location,
			ResourceGroupName: exampleResourceGroup.Name,
			AddressSpaces: pulumi.StringArray{
				pulumi.String("10.0.0.0/16"),
			},
		})
		if err != nil {
			return err
		}
		exampleSubnet, err := network.NewSubnet(ctx, "exampleSubnet", &network.SubnetArgs{
			ResourceGroupName:  exampleResourceGroup.Name,
			VirtualNetworkName: exampleVirtualNetwork.Name,
			AddressPrefixes: pulumi.StringArray{
				pulumi.String("10.0.1.0/24"),
			},
		})
		if err != nil {
			return err
		}
		exampleServicePrincipal, err := azuread.LookupServicePrincipal(ctx, &azuread.LookupServicePrincipalArgs{
			DisplayName: pulumi.StringRef("Azure Cosmos DB"),
		}, nil)
		if err != nil {
			return err
		}
		exampleAssignment, err := authorization.NewAssignment(ctx, "exampleAssignment", &authorization.AssignmentArgs{
			Scope:              exampleVirtualNetwork.ID(),
			RoleDefinitionName: pulumi.String("Network Contributor"),
			PrincipalId:        *pulumi.String(exampleServicePrincipal.ObjectId),
		})
		if err != nil {
			return err
		}
		_, err = cosmosdb.NewCassandraCluster(ctx, "exampleCassandraCluster", &cosmosdb.CassandraClusterArgs{
			ResourceGroupName:           exampleResourceGroup.Name,
			Location:                    exampleResourceGroup.Location,
			DelegatedManagementSubnetId: exampleSubnet.ID(),
			DefaultAdminPassword:        pulumi.String("Password1234"),
		}, pulumi.DependsOn([]pulumi.Resource{
			exampleAssignment,
		}))
		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.core.ResourceGroup;
import com.pulumi.azure.core.ResourceGroupArgs;
import com.pulumi.azure.network.VirtualNetwork;
import com.pulumi.azure.network.VirtualNetworkArgs;
import com.pulumi.azure.network.Subnet;
import com.pulumi.azure.network.SubnetArgs;
import com.pulumi.azuread.AzureadFunctions;
import com.pulumi.azuread.inputs.GetServicePrincipalArgs;
import com.pulumi.azure.authorization.Assignment;
import com.pulumi.azure.authorization.AssignmentArgs;
import com.pulumi.azure.cosmosdb.CassandraCluster;
import com.pulumi.azure.cosmosdb.CassandraClusterArgs;
import com.pulumi.resources.CustomResourceOptions;
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 exampleResourceGroup = new ResourceGroup("exampleResourceGroup", ResourceGroupArgs.builder()        
            .location("West Europe")
            .build());

        var exampleVirtualNetwork = new VirtualNetwork("exampleVirtualNetwork", VirtualNetworkArgs.builder()        
            .location(exampleResourceGroup.location())
            .resourceGroupName(exampleResourceGroup.name())
            .addressSpaces("10.0.0.0/16")
            .build());

        var exampleSubnet = new Subnet("exampleSubnet", SubnetArgs.builder()        
            .resourceGroupName(exampleResourceGroup.name())
            .virtualNetworkName(exampleVirtualNetwork.name())
            .addressPrefixes("10.0.1.0/24")
            .build());

        final var exampleServicePrincipal = AzureadFunctions.getServicePrincipal(GetServicePrincipalArgs.builder()
            .displayName("Azure Cosmos DB")
            .build());

        var exampleAssignment = new Assignment("exampleAssignment", AssignmentArgs.builder()        
            .scope(exampleVirtualNetwork.id())
            .roleDefinitionName("Network Contributor")
            .principalId(exampleServicePrincipal.applyValue(getServicePrincipalResult -> getServicePrincipalResult.objectId()))
            .build());

        var exampleCassandraCluster = new CassandraCluster("exampleCassandraCluster", CassandraClusterArgs.builder()        
            .resourceGroupName(exampleResourceGroup.name())
            .location(exampleResourceGroup.location())
            .delegatedManagementSubnetId(exampleSubnet.id())
            .defaultAdminPassword("Password1234")
            .build(), CustomResourceOptions.builder()
                .dependsOn(exampleAssignment)
                .build());

    }
}

import pulumi
import pulumi_azure as azure
import pulumi_azuread as azuread

example_resource_group = azure.core.ResourceGroup("exampleResourceGroup", location="West Europe")
example_virtual_network = azure.network.VirtualNetwork("exampleVirtualNetwork",
    location=example_resource_group.location,
    resource_group_name=example_resource_group.name,
    address_spaces=["10.0.0.0/16"])
example_subnet = azure.network.Subnet("exampleSubnet",
    resource_group_name=example_resource_group.name,
    virtual_network_name=example_virtual_network.name,
    address_prefixes=["10.0.1.0/24"])
example_service_principal = azuread.get_service_principal(display_name="Azure Cosmos DB")
example_assignment = azure.authorization.Assignment("exampleAssignment",
    scope=example_virtual_network.id,
    role_definition_name="Network Contributor",
    principal_id=example_service_principal.object_id)
example_cassandra_cluster = azure.cosmosdb.CassandraCluster("exampleCassandraCluster",
    resource_group_name=example_resource_group.name,
    location=example_resource_group.location,
    delegated_management_subnet_id=example_subnet.id,
    default_admin_password="Password1234",
    opts=pulumi.ResourceOptions(depends_on=[example_assignment]))

import * as pulumi from "@pulumi/pulumi";
import * as azure from "@pulumi/azure";
import * as azuread from "@pulumi/azuread";

const exampleResourceGroup = new azure.core.ResourceGroup("exampleResourceGroup", {location: "West Europe"});
const exampleVirtualNetwork = new azure.network.VirtualNetwork("exampleVirtualNetwork", {
    location: exampleResourceGroup.location,
    resourceGroupName: exampleResourceGroup.name,
    addressSpaces: ["10.0.0.0/16"],
});
const exampleSubnet = new azure.network.Subnet("exampleSubnet", {
    resourceGroupName: exampleResourceGroup.name,
    virtualNetworkName: exampleVirtualNetwork.name,
    addressPrefixes: ["10.0.1.0/24"],
});
const exampleServicePrincipal = azuread.getServicePrincipal({
    displayName: "Azure Cosmos DB",
});
const exampleAssignment = new azure.authorization.Assignment("exampleAssignment", {
    scope: exampleVirtualNetwork.id,
    roleDefinitionName: "Network Contributor",
    principalId: exampleServicePrincipal.then(exampleServicePrincipal => exampleServicePrincipal.objectId),
});
const exampleCassandraCluster = new azure.cosmosdb.CassandraCluster("exampleCassandraCluster", {
    resourceGroupName: exampleResourceGroup.name,
    location: exampleResourceGroup.location,
    delegatedManagementSubnetId: exampleSubnet.id,
    defaultAdminPassword: "Password1234",
}, {
    dependsOn: [exampleAssignment],
});

resources:
  exampleResourceGroup:
    type: azure:core:ResourceGroup
    properties:
      location: West Europe
  exampleVirtualNetwork:
    type: azure:network:VirtualNetwork
    properties:
      location: ${exampleResourceGroup.location}
      resourceGroupName: ${exampleResourceGroup.name}
      addressSpaces:
        - 10.0.0.0/16
  exampleSubnet:
    type: azure:network:Subnet
    properties:
      resourceGroupName: ${exampleResourceGroup.name}
      virtualNetworkName: ${exampleVirtualNetwork.name}
      addressPrefixes:
        - 10.0.1.0/24
  exampleAssignment:
    type: azure:authorization:Assignment
    properties:
      scope: ${exampleVirtualNetwork.id}
      roleDefinitionName: Network Contributor
      principalId: ${exampleServicePrincipal.objectId}
  exampleCassandraCluster:
    type: azure:cosmosdb:CassandraCluster
    properties:
      resourceGroupName: ${exampleResourceGroup.name}
      location: ${exampleResourceGroup.location}
      delegatedManagementSubnetId: ${exampleSubnet.id}
      defaultAdminPassword: Password1234
    options:
      dependson:
        - ${exampleAssignment}
variables:
  exampleServicePrincipal:
    fn::invoke:
      Function: azuread:getServicePrincipal
      Arguments:
        displayName: Azure Cosmos DB