azuread.SynchronizationSecret

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

const example = azuread.getApplicationTemplate({
    displayName: "Azure Databricks SCIM Provisioning Connector",
});
const exampleApplication = new azuread.Application("example", {
    displayName: "example",
    templateId: example.then(example => example.templateId),
    featureTags: [{
        enterprise: true,
        gallery: true,
    }],
});
const exampleServicePrincipal = new azuread.ServicePrincipal("example", {
    applicationId: exampleApplication.applicationId,
    useExisting: true,
});
const exampleSynchronizationSecret = new azuread.SynchronizationSecret("example", {
    servicePrincipalId: exampleServicePrincipal.id,
    credentials: [
        {
            key: "BaseAddress",
            value: "abc",
        },
        {
            key: "SecretToken",
            value: "some-token",
        },
    ],
});

import pulumi
import pulumi_azuread as azuread

example = azuread.get_application_template(display_name="Azure Databricks SCIM Provisioning Connector")
example_application = azuread.Application("example",
    display_name="example",
    template_id=example.template_id,
    feature_tags=[azuread.ApplicationFeatureTagArgs(
        enterprise=True,
        gallery=True,
    )])
example_service_principal = azuread.ServicePrincipal("example",
    application_id=example_application.application_id,
    use_existing=True)
example_synchronization_secret = azuread.SynchronizationSecret("example",
    service_principal_id=example_service_principal.id,
    credentials=[
        azuread.SynchronizationSecretCredentialArgs(
            key="BaseAddress",
            value="abc",
        ),
        azuread.SynchronizationSecretCredentialArgs(
            key="SecretToken",
            value="some-token",
        ),
    ])

package main

import (
	"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 {
		example, err := azuread.GetApplicationTemplate(ctx, &azuread.GetApplicationTemplateArgs{
			DisplayName: pulumi.StringRef("Azure Databricks SCIM Provisioning Connector"),
		}, nil)
		if err != nil {
			return err
		}
		exampleApplication, err := azuread.NewApplication(ctx, "example", &azuread.ApplicationArgs{
			DisplayName: pulumi.String("example"),
			TemplateId:  pulumi.String(example.TemplateId),
			FeatureTags: azuread.ApplicationFeatureTagArray{
				&azuread.ApplicationFeatureTagArgs{
					Enterprise: pulumi.Bool(true),
					Gallery:    pulumi.Bool(true),
				},
			},
		})
		if err != nil {
			return err
		}
		exampleServicePrincipal, err := azuread.NewServicePrincipal(ctx, "example", &azuread.ServicePrincipalArgs{
			ApplicationId: exampleApplication.ApplicationId,
			UseExisting:   pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		_, err = azuread.NewSynchronizationSecret(ctx, "example", &azuread.SynchronizationSecretArgs{
			ServicePrincipalId: exampleServicePrincipal.ID(),
			Credentials: azuread.SynchronizationSecretCredentialArray{
				&azuread.SynchronizationSecretCredentialArgs{
					Key:   pulumi.String("BaseAddress"),
					Value: pulumi.String("abc"),
				},
				&azuread.SynchronizationSecretCredentialArgs{
					Key:   pulumi.String("SecretToken"),
					Value: pulumi.String("some-token"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var example = AzureAD.GetApplicationTemplate.Invoke(new()
    {
        DisplayName = "Azure Databricks SCIM Provisioning Connector",
    });

    var exampleApplication = new AzureAD.Application("example", new()
    {
        DisplayName = "example",
        TemplateId = example.Apply(getApplicationTemplateResult => getApplicationTemplateResult.TemplateId),
        FeatureTags = new[]
        {
            new AzureAD.Inputs.ApplicationFeatureTagArgs
            {
                Enterprise = true,
                Gallery = true,
            },
        },
    });

    var exampleServicePrincipal = new AzureAD.ServicePrincipal("example", new()
    {
        ApplicationId = exampleApplication.ApplicationId,
        UseExisting = true,
    });

    var exampleSynchronizationSecret = new AzureAD.SynchronizationSecret("example", new()
    {
        ServicePrincipalId = exampleServicePrincipal.Id,
        Credentials = new[]
        {
            new AzureAD.Inputs.SynchronizationSecretCredentialArgs
            {
                Key = "BaseAddress",
                Value = "abc",
            },
            new AzureAD.Inputs.SynchronizationSecretCredentialArgs
            {
                Key = "SecretToken",
                Value = "some-token",
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azuread.AzureadFunctions;
import com.pulumi.azuread.inputs.GetApplicationTemplateArgs;
import com.pulumi.azuread.Application;
import com.pulumi.azuread.ApplicationArgs;
import com.pulumi.azuread.inputs.ApplicationFeatureTagArgs;
import com.pulumi.azuread.ServicePrincipal;
import com.pulumi.azuread.ServicePrincipalArgs;
import com.pulumi.azuread.SynchronizationSecret;
import com.pulumi.azuread.SynchronizationSecretArgs;
import com.pulumi.azuread.inputs.SynchronizationSecretCredentialArgs;
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) {
        final var example = AzureadFunctions.getApplicationTemplate(GetApplicationTemplateArgs.builder()
            .displayName("Azure Databricks SCIM Provisioning Connector")
            .build());

        var exampleApplication = new Application("exampleApplication", ApplicationArgs.builder()
            .displayName("example")
            .templateId(example.applyValue(getApplicationTemplateResult -> getApplicationTemplateResult.templateId()))
            .featureTags(ApplicationFeatureTagArgs.builder()
                .enterprise(true)
                .gallery(true)
                .build())
            .build());

        var exampleServicePrincipal = new ServicePrincipal("exampleServicePrincipal", ServicePrincipalArgs.builder()
            .applicationId(exampleApplication.applicationId())
            .useExisting(true)
            .build());

        var exampleSynchronizationSecret = new SynchronizationSecret("exampleSynchronizationSecret", SynchronizationSecretArgs.builder()
            .servicePrincipalId(exampleServicePrincipal.id())
            .credentials(            
                SynchronizationSecretCredentialArgs.builder()
                    .key("BaseAddress")
                    .value("abc")
                    .build(),
                SynchronizationSecretCredentialArgs.builder()
                    .key("SecretToken")
                    .value("some-token")
                    .build())
            .build());

    }
}

resources:
  exampleApplication:
    type: azuread:Application
    name: example
    properties:
      displayName: example
      templateId: ${example.templateId}
      featureTags:
        - enterprise: true
          gallery: true
  exampleServicePrincipal:
    type: azuread:ServicePrincipal
    name: example
    properties:
      applicationId: ${exampleApplication.applicationId}
      useExisting: true
  exampleSynchronizationSecret:
    type: azuread:SynchronizationSecret
    name: example
    properties:
      servicePrincipalId: ${exampleServicePrincipal.id}
      credentials:
        - key: BaseAddress
          value: abc
        - key: SecretToken
          value: some-token
variables:
  example:
    fn::invoke:
      Function: azuread:getApplicationTemplate
      Arguments:
        displayName: Azure Databricks SCIM Provisioning Connector

var synchronizationSecretResource = new AzureAD.SynchronizationSecret("synchronizationSecretResource", new()
{
    ServicePrincipalId = "string",
    Credentials = new[]
    {
        new AzureAD.Inputs.SynchronizationSecretCredentialArgs
        {
            Key = "string",
            Value = "string",
        },
    },
});

example, err := azuread.NewSynchronizationSecret(ctx, "synchronizationSecretResource", &azuread.SynchronizationSecretArgs{
	ServicePrincipalId: pulumi.String("string"),
	Credentials: azuread.SynchronizationSecretCredentialArray{
		&azuread.SynchronizationSecretCredentialArgs{
			Key:   pulumi.String("string"),
			Value: pulumi.String("string"),
		},
	},
})

var synchronizationSecretResource = new SynchronizationSecret("synchronizationSecretResource", SynchronizationSecretArgs.builder()
    .servicePrincipalId("string")
    .credentials(SynchronizationSecretCredentialArgs.builder()
        .key("string")
        .value("string")
        .build())
    .build());

synchronization_secret_resource = azuread.SynchronizationSecret("synchronizationSecretResource",
    service_principal_id="string",
    credentials=[azuread.SynchronizationSecretCredentialArgs(
        key="string",
        value="string",
    )])

const synchronizationSecretResource = new azuread.SynchronizationSecret("synchronizationSecretResource", {
    servicePrincipalId: "string",
    credentials: [{
        key: "string",
        value: "string",
    }],
});

type: azuread:SynchronizationSecret
properties:
    credentials:
        - key: string
          value: string
    servicePrincipalId: string