Choosing a Pulumi Azure Provider

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

// Create a resource group using the Azure Native provider.
const resourceGroup = new resources.ResourceGroup("my-resource-group", {
    location: "eastus",
});

// Create an Entra ID application registration using the Azure AD provider.
const application = new azuread.Application("my-application", {
    displayName: "my-application",
});

// Create a service principal for the application.
const servicePrincipal = new azuread.ServicePrincipal("my-service-principal", {
    clientId: application.clientId,
});

export const resourceGroupName = resourceGroup.name;
export const applicationClientId = application.clientId;
export const servicePrincipalId = servicePrincipal.id;

import pulumi
import pulumi_azuread as azuread
import pulumi_azure_native.resources as resources

# Create a resource group using the Azure Native provider.
resource_group = resources.ResourceGroup("my-resource-group",
    location="eastus",
)

# Create an Entra ID application registration using the Azure AD provider.
application = azuread.Application("my-application",
    display_name="my-application",
)

# Create a service principal for the application.
service_principal = azuread.ServicePrincipal("my-service-principal",
    client_id=application.client_id,
)

pulumi.export("resourceGroupName", resource_group.name)
pulumi.export("applicationClientId", application.client_id)
pulumi.export("servicePrincipalId", service_principal.id)

package main

import (
	"github.com/pulumi/pulumi-azure-native-sdk/resources/v3"
	"github.com/pulumi/pulumi-azuread/sdk/v6/go/azuread"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// Create a resource group using the Azure Native provider.
		resourceGroup, err := resources.NewResourceGroup(ctx, "my-resource-group", &resources.ResourceGroupArgs{
			Location: pulumi.String("eastus"),
		})
		if err != nil {
			return err
		}

		// Create an Entra ID application registration using the Azure AD provider.
		application, err := azuread.NewApplication(ctx, "my-application", &azuread.ApplicationArgs{
			DisplayName: pulumi.String("my-application"),
		})
		if err != nil {
			return err
		}

		// Create a service principal for the application.
		servicePrincipal, err := azuread.NewServicePrincipal(ctx, "my-service-principal", &azuread.ServicePrincipalArgs{
			ClientId: application.ClientId,
		})
		if err != nil {
			return err
		}

		ctx.Export("resourceGroupName", resourceGroup.Name)
		ctx.Export("applicationClientId", application.ClientId)
		ctx.Export("servicePrincipalId", servicePrincipal.ID())
		return nil
	})
}

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

return await Deployment.RunAsync(() =>
{
    // Create a resource group using the Azure Native provider.
    var resourceGroup = new AzureNative.Resources.ResourceGroup("my-resource-group", new()
    {
        Location = "eastus",
    });

    // Create an Entra ID application registration using the Azure AD provider.
    var application = new AzureAD.Application("my-application", new()
    {
        DisplayName = "my-application",
    });

    // Create a service principal for the application.
    var servicePrincipal = new AzureAD.ServicePrincipal("my-service-principal", new()
    {
        ClientId = application.ClientId,
    });

    return new Dictionary<string, object?>
    {
        ["resourceGroupName"] = resourceGroup.Name,
        ["applicationClientId"] = application.ClientId,
        ["servicePrincipalId"] = servicePrincipal.Id,
    };
});

package myproject;

import com.pulumi.Pulumi;
import com.pulumi.azurenative.resources.ResourceGroup;
import com.pulumi.azurenative.resources.ResourceGroupArgs;
import com.pulumi.azuread.Application;
import com.pulumi.azuread.ApplicationArgs;
import com.pulumi.azuread.ServicePrincipal;
import com.pulumi.azuread.ServicePrincipalArgs;

public class App {
    public static void main(String[] args) {
        Pulumi.run(ctx -> {
            // Create a resource group using the Azure Native provider.
            var resourceGroup = new ResourceGroup("my-resource-group", ResourceGroupArgs.builder()
                .location("eastus")
                .build());

            // Create an Entra ID application registration using the Azure AD provider.
            var application = new Application("my-application", ApplicationArgs.builder()
                .displayName("my-application")
                .build());

            // Create a service principal for the application.
            var servicePrincipal = new ServicePrincipal("my-service-principal", ServicePrincipalArgs.builder()
                .clientId(application.clientId())
                .build());

            ctx.export("resourceGroupName", resourceGroup.name());
            ctx.export("applicationClientId", application.clientId());
            ctx.export("servicePrincipalId", servicePrincipal.id());
        });
    }
}

name: azure-providers-yaml
description: An example that uses the Azure Native and Azure AD providers together to create a resource group and an Entra ID service principal.
runtime: yaml
config:
  pulumi:tags:
    value:
      pulumi:template: azure-yaml

resources:
  # Create a resource group using the Azure Native provider.
  my-resource-group:
    type: azure-native:resources:ResourceGroup
    properties:
      location: eastus

  # Create an Entra ID application registration using the Azure AD provider.
  my-application:
    type: azuread:Application
    properties:
      displayName: my-application

  # Create a service principal for the application.
  my-service-principal:
    type: azuread:ServicePrincipal
    properties:
      clientId: ${my-application.clientId}

outputs:
  resourceGroupName: ${my-resource-group.name}
  applicationClientId: ${my-application.clientId}
  servicePrincipalId: ${my-service-principal.id}