1. Packages
  2. Auth0 Provider
  3. API Docs
  4. ConnectionScimConfiguration
Auth0 v3.17.1 published on Tuesday, Apr 15, 2025 by Pulumi

auth0.ConnectionScimConfiguration

Explore with Pulumi AI

With this resource, you can configure SCIM(System for Cross-domain Identity Management) support for SAML and OpenID Connect Enterprise connections.

Example Usage

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

const myEnterpriseConnection = new auth0.Connection("my_enterprise_connection", {
    name: "my-enterprise-connection",
    displayName: "My Enterprise Connection",
    strategy: "okta",
    options: {
        clientId: "1234567",
        clientSecret: "1234567",
        issuer: "https://example.okta.com",
        jwksUri: "https://example.okta.com/oauth2/v1/keys",
        tokenEndpoint: "https://example.okta.com/oauth2/v1/token",
        authorizationEndpoint: "https://example.okta.com/oauth2/v1/authorize",
    },
});
const myEnterpriseConnection2 = new auth0.Connection("my_enterprise_connection_2", {
    name: "my-enterprise-connection-2",
    displayName: "My Enterprise Connection 2",
    strategy: "okta",
    options: {
        clientId: "1234567",
        clientSecret: "1234567",
        issuer: "https://example.okta.com",
        jwksUri: "https://example.okta.com/oauth2/v1/keys",
        tokenEndpoint: "https://example.okta.com/oauth2/v1/token",
        authorizationEndpoint: "https://example.okta.com/oauth2/v1/authorize",
    },
});
// A resource for configuring an Auth0 Connection SCIM Configuration, using default values.
// Only one can be specified for a connection.
const myConnScimConfigurationDefault = new auth0.ConnectionScimConfiguration("my_conn_scim_configuration_default", {connectionId: myEnterpriseConnection.id});
// A resource for configuring an Auth0 Connection SCIM Configuration, specifying `user_id_attribute` and `mapping`.
// Only one can be specified for a connection.
const myConnScimConfiguration = new auth0.ConnectionScimConfiguration("my_conn_scim_configuration", {
    connectionId: myEnterpriseConnection2.id,
    userIdAttribute: "attribute1",
    mappings: [
        {
            auth0: "auth0_attribute1",
            scim: "sacim_attribute1",
        },
        {
            auth0: "auth0_attribute2",
            scim: "sacim_attribute2",
        },
    ],
});
Copy
import pulumi
import pulumi_auth0 as auth0

my_enterprise_connection = auth0.Connection("my_enterprise_connection",
    name="my-enterprise-connection",
    display_name="My Enterprise Connection",
    strategy="okta",
    options={
        "client_id": "1234567",
        "client_secret": "1234567",
        "issuer": "https://example.okta.com",
        "jwks_uri": "https://example.okta.com/oauth2/v1/keys",
        "token_endpoint": "https://example.okta.com/oauth2/v1/token",
        "authorization_endpoint": "https://example.okta.com/oauth2/v1/authorize",
    })
my_enterprise_connection2 = auth0.Connection("my_enterprise_connection_2",
    name="my-enterprise-connection-2",
    display_name="My Enterprise Connection 2",
    strategy="okta",
    options={
        "client_id": "1234567",
        "client_secret": "1234567",
        "issuer": "https://example.okta.com",
        "jwks_uri": "https://example.okta.com/oauth2/v1/keys",
        "token_endpoint": "https://example.okta.com/oauth2/v1/token",
        "authorization_endpoint": "https://example.okta.com/oauth2/v1/authorize",
    })
# A resource for configuring an Auth0 Connection SCIM Configuration, using default values.
# Only one can be specified for a connection.
my_conn_scim_configuration_default = auth0.ConnectionScimConfiguration("my_conn_scim_configuration_default", connection_id=my_enterprise_connection.id)
# A resource for configuring an Auth0 Connection SCIM Configuration, specifying `user_id_attribute` and `mapping`.
# Only one can be specified for a connection.
my_conn_scim_configuration = auth0.ConnectionScimConfiguration("my_conn_scim_configuration",
    connection_id=my_enterprise_connection2.id,
    user_id_attribute="attribute1",
    mappings=[
        {
            "auth0": "auth0_attribute1",
            "scim": "sacim_attribute1",
        },
        {
            "auth0": "auth0_attribute2",
            "scim": "sacim_attribute2",
        },
    ])
Copy
package main

import (
	"github.com/pulumi/pulumi-auth0/sdk/v3/go/auth0"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		myEnterpriseConnection, err := auth0.NewConnection(ctx, "my_enterprise_connection", &auth0.ConnectionArgs{
			Name:        pulumi.String("my-enterprise-connection"),
			DisplayName: pulumi.String("My Enterprise Connection"),
			Strategy:    pulumi.String("okta"),
			Options: &auth0.ConnectionOptionsArgs{
				ClientId:              pulumi.String("1234567"),
				ClientSecret:          pulumi.String("1234567"),
				Issuer:                pulumi.String("https://example.okta.com"),
				JwksUri:               pulumi.String("https://example.okta.com/oauth2/v1/keys"),
				TokenEndpoint:         pulumi.String("https://example.okta.com/oauth2/v1/token"),
				AuthorizationEndpoint: pulumi.String("https://example.okta.com/oauth2/v1/authorize"),
			},
		})
		if err != nil {
			return err
		}
		myEnterpriseConnection2, err := auth0.NewConnection(ctx, "my_enterprise_connection_2", &auth0.ConnectionArgs{
			Name:        pulumi.String("my-enterprise-connection-2"),
			DisplayName: pulumi.String("My Enterprise Connection 2"),
			Strategy:    pulumi.String("okta"),
			Options: &auth0.ConnectionOptionsArgs{
				ClientId:              pulumi.String("1234567"),
				ClientSecret:          pulumi.String("1234567"),
				Issuer:                pulumi.String("https://example.okta.com"),
				JwksUri:               pulumi.String("https://example.okta.com/oauth2/v1/keys"),
				TokenEndpoint:         pulumi.String("https://example.okta.com/oauth2/v1/token"),
				AuthorizationEndpoint: pulumi.String("https://example.okta.com/oauth2/v1/authorize"),
			},
		})
		if err != nil {
			return err
		}
		// A resource for configuring an Auth0 Connection SCIM Configuration, using default values.
		// Only one can be specified for a connection.
		_, err = auth0.NewConnectionScimConfiguration(ctx, "my_conn_scim_configuration_default", &auth0.ConnectionScimConfigurationArgs{
			ConnectionId: myEnterpriseConnection.ID(),
		})
		if err != nil {
			return err
		}
		// A resource for configuring an Auth0 Connection SCIM Configuration, specifying `user_id_attribute` and `mapping`.
		// Only one can be specified for a connection.
		_, err = auth0.NewConnectionScimConfiguration(ctx, "my_conn_scim_configuration", &auth0.ConnectionScimConfigurationArgs{
			ConnectionId:    myEnterpriseConnection2.ID(),
			UserIdAttribute: pulumi.String("attribute1"),
			Mappings: auth0.ConnectionScimConfigurationMappingArray{
				&auth0.ConnectionScimConfigurationMappingArgs{
					Auth0: pulumi.String("auth0_attribute1"),
					Scim:  pulumi.String("sacim_attribute1"),
				},
				&auth0.ConnectionScimConfigurationMappingArgs{
					Auth0: pulumi.String("auth0_attribute2"),
					Scim:  pulumi.String("sacim_attribute2"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Copy
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Auth0 = Pulumi.Auth0;

return await Deployment.RunAsync(() => 
{
    var myEnterpriseConnection = new Auth0.Connection("my_enterprise_connection", new()
    {
        Name = "my-enterprise-connection",
        DisplayName = "My Enterprise Connection",
        Strategy = "okta",
        Options = new Auth0.Inputs.ConnectionOptionsArgs
        {
            ClientId = "1234567",
            ClientSecret = "1234567",
            Issuer = "https://example.okta.com",
            JwksUri = "https://example.okta.com/oauth2/v1/keys",
            TokenEndpoint = "https://example.okta.com/oauth2/v1/token",
            AuthorizationEndpoint = "https://example.okta.com/oauth2/v1/authorize",
        },
    });

    var myEnterpriseConnection2 = new Auth0.Connection("my_enterprise_connection_2", new()
    {
        Name = "my-enterprise-connection-2",
        DisplayName = "My Enterprise Connection 2",
        Strategy = "okta",
        Options = new Auth0.Inputs.ConnectionOptionsArgs
        {
            ClientId = "1234567",
            ClientSecret = "1234567",
            Issuer = "https://example.okta.com",
            JwksUri = "https://example.okta.com/oauth2/v1/keys",
            TokenEndpoint = "https://example.okta.com/oauth2/v1/token",
            AuthorizationEndpoint = "https://example.okta.com/oauth2/v1/authorize",
        },
    });

    // A resource for configuring an Auth0 Connection SCIM Configuration, using default values.
    // Only one can be specified for a connection.
    var myConnScimConfigurationDefault = new Auth0.ConnectionScimConfiguration("my_conn_scim_configuration_default", new()
    {
        ConnectionId = myEnterpriseConnection.Id,
    });

    // A resource for configuring an Auth0 Connection SCIM Configuration, specifying `user_id_attribute` and `mapping`.
    // Only one can be specified for a connection.
    var myConnScimConfiguration = new Auth0.ConnectionScimConfiguration("my_conn_scim_configuration", new()
    {
        ConnectionId = myEnterpriseConnection2.Id,
        UserIdAttribute = "attribute1",
        Mappings = new[]
        {
            new Auth0.Inputs.ConnectionScimConfigurationMappingArgs
            {
                Auth0 = "auth0_attribute1",
                Scim = "sacim_attribute1",
            },
            new Auth0.Inputs.ConnectionScimConfigurationMappingArgs
            {
                Auth0 = "auth0_attribute2",
                Scim = "sacim_attribute2",
            },
        },
    });

});
Copy
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.auth0.Connection;
import com.pulumi.auth0.ConnectionArgs;
import com.pulumi.auth0.inputs.ConnectionOptionsArgs;
import com.pulumi.auth0.ConnectionScimConfiguration;
import com.pulumi.auth0.ConnectionScimConfigurationArgs;
import com.pulumi.auth0.inputs.ConnectionScimConfigurationMappingArgs;
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 myEnterpriseConnection = new Connection("myEnterpriseConnection", ConnectionArgs.builder()
            .name("my-enterprise-connection")
            .displayName("My Enterprise Connection")
            .strategy("okta")
            .options(ConnectionOptionsArgs.builder()
                .clientId("1234567")
                .clientSecret("1234567")
                .issuer("https://example.okta.com")
                .jwksUri("https://example.okta.com/oauth2/v1/keys")
                .tokenEndpoint("https://example.okta.com/oauth2/v1/token")
                .authorizationEndpoint("https://example.okta.com/oauth2/v1/authorize")
                .build())
            .build());

        var myEnterpriseConnection2 = new Connection("myEnterpriseConnection2", ConnectionArgs.builder()
            .name("my-enterprise-connection-2")
            .displayName("My Enterprise Connection 2")
            .strategy("okta")
            .options(ConnectionOptionsArgs.builder()
                .clientId("1234567")
                .clientSecret("1234567")
                .issuer("https://example.okta.com")
                .jwksUri("https://example.okta.com/oauth2/v1/keys")
                .tokenEndpoint("https://example.okta.com/oauth2/v1/token")
                .authorizationEndpoint("https://example.okta.com/oauth2/v1/authorize")
                .build())
            .build());

        // A resource for configuring an Auth0 Connection SCIM Configuration, using default values.
        // Only one can be specified for a connection.
        var myConnScimConfigurationDefault = new ConnectionScimConfiguration("myConnScimConfigurationDefault", ConnectionScimConfigurationArgs.builder()
            .connectionId(myEnterpriseConnection.id())
            .build());

        // A resource for configuring an Auth0 Connection SCIM Configuration, specifying `user_id_attribute` and `mapping`.
        // Only one can be specified for a connection.
        var myConnScimConfiguration = new ConnectionScimConfiguration("myConnScimConfiguration", ConnectionScimConfigurationArgs.builder()
            .connectionId(myEnterpriseConnection2.id())
            .userIdAttribute("attribute1")
            .mappings(            
                ConnectionScimConfigurationMappingArgs.builder()
                    .auth0("auth0_attribute1")
                    .scim("sacim_attribute1")
                    .build(),
                ConnectionScimConfigurationMappingArgs.builder()
                    .auth0("auth0_attribute2")
                    .scim("sacim_attribute2")
                    .build())
            .build());

    }
}
Copy
resources:
  myEnterpriseConnection:
    type: auth0:Connection
    name: my_enterprise_connection
    properties:
      name: my-enterprise-connection
      displayName: My Enterprise Connection
      strategy: okta
      options:
        clientId: '1234567'
        clientSecret: '1234567'
        issuer: https://example.okta.com
        jwksUri: https://example.okta.com/oauth2/v1/keys
        tokenEndpoint: https://example.okta.com/oauth2/v1/token
        authorizationEndpoint: https://example.okta.com/oauth2/v1/authorize
  myEnterpriseConnection2:
    type: auth0:Connection
    name: my_enterprise_connection_2
    properties:
      name: my-enterprise-connection-2
      displayName: My Enterprise Connection 2
      strategy: okta
      options:
        clientId: '1234567'
        clientSecret: '1234567'
        issuer: https://example.okta.com
        jwksUri: https://example.okta.com/oauth2/v1/keys
        tokenEndpoint: https://example.okta.com/oauth2/v1/token
        authorizationEndpoint: https://example.okta.com/oauth2/v1/authorize
  # A resource for configuring an Auth0 Connection SCIM Configuration, using default values.
  # Only one can be specified for a connection.
  myConnScimConfigurationDefault:
    type: auth0:ConnectionScimConfiguration
    name: my_conn_scim_configuration_default
    properties:
      connectionId: ${myEnterpriseConnection.id}
  # A resource for configuring an Auth0 Connection SCIM Configuration, specifying `user_id_attribute` and `mapping`.
  # Only one can be specified for a connection.
  myConnScimConfiguration:
    type: auth0:ConnectionScimConfiguration
    name: my_conn_scim_configuration
    properties:
      connectionId: ${myEnterpriseConnection2.id}
      userIdAttribute: attribute1
      mappings:
        - auth0: auth0_attribute1
          scim: sacim_attribute1
        - auth0: auth0_attribute2
          scim: sacim_attribute2
Copy

Create ConnectionScimConfiguration Resource

Resources are created with functions called constructors. To learn more about declaring and configuring resources, see Resources.

Constructor syntax

new ConnectionScimConfiguration(name: string, args: ConnectionScimConfigurationArgs, opts?: CustomResourceOptions);
@overload
def ConnectionScimConfiguration(resource_name: str,
                                args: ConnectionScimConfigurationArgs,
                                opts: Optional[ResourceOptions] = None)

@overload
def ConnectionScimConfiguration(resource_name: str,
                                opts: Optional[ResourceOptions] = None,
                                connection_id: Optional[str] = None,
                                mappings: Optional[Sequence[ConnectionScimConfigurationMappingArgs]] = None,
                                user_id_attribute: Optional[str] = None)
func NewConnectionScimConfiguration(ctx *Context, name string, args ConnectionScimConfigurationArgs, opts ...ResourceOption) (*ConnectionScimConfiguration, error)
public ConnectionScimConfiguration(string name, ConnectionScimConfigurationArgs args, CustomResourceOptions? opts = null)
public ConnectionScimConfiguration(String name, ConnectionScimConfigurationArgs args)
public ConnectionScimConfiguration(String name, ConnectionScimConfigurationArgs args, CustomResourceOptions options)
type: auth0:ConnectionScimConfiguration
properties: # The arguments to resource properties.
options: # Bag of options to control resource's behavior.

Parameters

name This property is required. string
The unique name of the resource.
args This property is required. ConnectionScimConfigurationArgs
The arguments to resource properties.
opts CustomResourceOptions
Bag of options to control resource's behavior.
resource_name This property is required. str
The unique name of the resource.
args This property is required. ConnectionScimConfigurationArgs
The arguments to resource properties.
opts ResourceOptions
Bag of options to control resource's behavior.
ctx Context
Context object for the current deployment.
name This property is required. string
The unique name of the resource.
args This property is required. ConnectionScimConfigurationArgs
The arguments to resource properties.
opts ResourceOption
Bag of options to control resource's behavior.
name This property is required. string
The unique name of the resource.
args This property is required. ConnectionScimConfigurationArgs
The arguments to resource properties.
opts CustomResourceOptions
Bag of options to control resource's behavior.
name This property is required. String
The unique name of the resource.
args This property is required. ConnectionScimConfigurationArgs
The arguments to resource properties.
options CustomResourceOptions
Bag of options to control resource's behavior.

Constructor example

The following reference example uses placeholder values for all input properties.

var connectionScimConfigurationResource = new Auth0.ConnectionScimConfiguration("connectionScimConfigurationResource", new()
{
    ConnectionId = "string",
    Mappings = new[]
    {
        new Auth0.Inputs.ConnectionScimConfigurationMappingArgs
        {
            Auth0 = "string",
            Scim = "string",
        },
    },
    UserIdAttribute = "string",
});
Copy
example, err := auth0.NewConnectionScimConfiguration(ctx, "connectionScimConfigurationResource", &auth0.ConnectionScimConfigurationArgs{
	ConnectionId: pulumi.String("string"),
	Mappings: auth0.ConnectionScimConfigurationMappingArray{
		&auth0.ConnectionScimConfigurationMappingArgs{
			Auth0: pulumi.String("string"),
			Scim:  pulumi.String("string"),
		},
	},
	UserIdAttribute: pulumi.String("string"),
})
Copy
var connectionScimConfigurationResource = new ConnectionScimConfiguration("connectionScimConfigurationResource", ConnectionScimConfigurationArgs.builder()
    .connectionId("string")
    .mappings(ConnectionScimConfigurationMappingArgs.builder()
        .auth0("string")
        .scim("string")
        .build())
    .userIdAttribute("string")
    .build());
Copy
connection_scim_configuration_resource = auth0.ConnectionScimConfiguration("connectionScimConfigurationResource",
    connection_id="string",
    mappings=[{
        "auth0": "string",
        "scim": "string",
    }],
    user_id_attribute="string")
Copy
const connectionScimConfigurationResource = new auth0.ConnectionScimConfiguration("connectionScimConfigurationResource", {
    connectionId: "string",
    mappings: [{
        auth0: "string",
        scim: "string",
    }],
    userIdAttribute: "string",
});
Copy
type: auth0:ConnectionScimConfiguration
properties:
    connectionId: string
    mappings:
        - auth0: string
          scim: string
    userIdAttribute: string
Copy

ConnectionScimConfiguration Resource Properties

To learn more about resource properties and how to use them, see Inputs and Outputs in the Architecture and Concepts docs.

Inputs

In Python, inputs that are objects can be passed either as argument classes or as dictionary literals.

The ConnectionScimConfiguration resource accepts the following input properties:

ConnectionId
This property is required.
Changes to this property will trigger replacement.
string
ID of the connection for this SCIM configuration.
Mappings List<ConnectionScimConfigurationMapping>
Mapping between Auth0 attributes and SCIM attributes. If user_id_attribute is set, mapping must be set as well.
UserIdAttribute string
User ID attribute for generation unique of user ids. If user_id_attribute is set, mapping must be set as well. Defaults to userName for SAML connections and externalId for OIDC connections.
ConnectionId
This property is required.
Changes to this property will trigger replacement.
string
ID of the connection for this SCIM configuration.
Mappings []ConnectionScimConfigurationMappingArgs
Mapping between Auth0 attributes and SCIM attributes. If user_id_attribute is set, mapping must be set as well.
UserIdAttribute string
User ID attribute for generation unique of user ids. If user_id_attribute is set, mapping must be set as well. Defaults to userName for SAML connections and externalId for OIDC connections.
connectionId
This property is required.
Changes to this property will trigger replacement.
String
ID of the connection for this SCIM configuration.
mappings List<ConnectionScimConfigurationMapping>
Mapping between Auth0 attributes and SCIM attributes. If user_id_attribute is set, mapping must be set as well.
userIdAttribute String
User ID attribute for generation unique of user ids. If user_id_attribute is set, mapping must be set as well. Defaults to userName for SAML connections and externalId for OIDC connections.
connectionId
This property is required.
Changes to this property will trigger replacement.
string
ID of the connection for this SCIM configuration.
mappings ConnectionScimConfigurationMapping[]
Mapping between Auth0 attributes and SCIM attributes. If user_id_attribute is set, mapping must be set as well.
userIdAttribute string
User ID attribute for generation unique of user ids. If user_id_attribute is set, mapping must be set as well. Defaults to userName for SAML connections and externalId for OIDC connections.
connection_id
This property is required.
Changes to this property will trigger replacement.
str
ID of the connection for this SCIM configuration.
mappings Sequence[ConnectionScimConfigurationMappingArgs]
Mapping between Auth0 attributes and SCIM attributes. If user_id_attribute is set, mapping must be set as well.
user_id_attribute str
User ID attribute for generation unique of user ids. If user_id_attribute is set, mapping must be set as well. Defaults to userName for SAML connections and externalId for OIDC connections.
connectionId
This property is required.
Changes to this property will trigger replacement.
String
ID of the connection for this SCIM configuration.
mappings List<Property Map>
Mapping between Auth0 attributes and SCIM attributes. If user_id_attribute is set, mapping must be set as well.
userIdAttribute String
User ID attribute for generation unique of user ids. If user_id_attribute is set, mapping must be set as well. Defaults to userName for SAML connections and externalId for OIDC connections.

Outputs

All input properties are implicitly available as output properties. Additionally, the ConnectionScimConfiguration resource produces the following output properties:

ConnectionName string
Name of the connection for this SCIM configuration.
Id string
The provider-assigned unique ID for this managed resource.
Strategy string
Schema of the connection for this SCIM configuration.
TenantName string
Name of the tenant for this SCIM configuration.
ConnectionName string
Name of the connection for this SCIM configuration.
Id string
The provider-assigned unique ID for this managed resource.
Strategy string
Schema of the connection for this SCIM configuration.
TenantName string
Name of the tenant for this SCIM configuration.
connectionName String
Name of the connection for this SCIM configuration.
id String
The provider-assigned unique ID for this managed resource.
strategy String
Schema of the connection for this SCIM configuration.
tenantName String
Name of the tenant for this SCIM configuration.
connectionName string
Name of the connection for this SCIM configuration.
id string
The provider-assigned unique ID for this managed resource.
strategy string
Schema of the connection for this SCIM configuration.
tenantName string
Name of the tenant for this SCIM configuration.
connection_name str
Name of the connection for this SCIM configuration.
id str
The provider-assigned unique ID for this managed resource.
strategy str
Schema of the connection for this SCIM configuration.
tenant_name str
Name of the tenant for this SCIM configuration.
connectionName String
Name of the connection for this SCIM configuration.
id String
The provider-assigned unique ID for this managed resource.
strategy String
Schema of the connection for this SCIM configuration.
tenantName String
Name of the tenant for this SCIM configuration.

Look up Existing ConnectionScimConfiguration Resource

Get an existing ConnectionScimConfiguration resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

public static get(name: string, id: Input<ID>, state?: ConnectionScimConfigurationState, opts?: CustomResourceOptions): ConnectionScimConfiguration
@staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        connection_id: Optional[str] = None,
        connection_name: Optional[str] = None,
        mappings: Optional[Sequence[ConnectionScimConfigurationMappingArgs]] = None,
        strategy: Optional[str] = None,
        tenant_name: Optional[str] = None,
        user_id_attribute: Optional[str] = None) -> ConnectionScimConfiguration
func GetConnectionScimConfiguration(ctx *Context, name string, id IDInput, state *ConnectionScimConfigurationState, opts ...ResourceOption) (*ConnectionScimConfiguration, error)
public static ConnectionScimConfiguration Get(string name, Input<string> id, ConnectionScimConfigurationState? state, CustomResourceOptions? opts = null)
public static ConnectionScimConfiguration get(String name, Output<String> id, ConnectionScimConfigurationState state, CustomResourceOptions options)
resources:  _:    type: auth0:ConnectionScimConfiguration    get:      id: ${id}
name This property is required.
The unique name of the resulting resource.
id This property is required.
The unique provider ID of the resource to lookup.
state
Any extra arguments used during the lookup.
opts
A bag of options that control this resource's behavior.
resource_name This property is required.
The unique name of the resulting resource.
id This property is required.
The unique provider ID of the resource to lookup.
name This property is required.
The unique name of the resulting resource.
id This property is required.
The unique provider ID of the resource to lookup.
state
Any extra arguments used during the lookup.
opts
A bag of options that control this resource's behavior.
name This property is required.
The unique name of the resulting resource.
id This property is required.
The unique provider ID of the resource to lookup.
state
Any extra arguments used during the lookup.
opts
A bag of options that control this resource's behavior.
name This property is required.
The unique name of the resulting resource.
id This property is required.
The unique provider ID of the resource to lookup.
state
Any extra arguments used during the lookup.
opts
A bag of options that control this resource's behavior.
The following state arguments are supported:
ConnectionId Changes to this property will trigger replacement. string
ID of the connection for this SCIM configuration.
ConnectionName string
Name of the connection for this SCIM configuration.
Mappings List<ConnectionScimConfigurationMapping>
Mapping between Auth0 attributes and SCIM attributes. If user_id_attribute is set, mapping must be set as well.
Strategy string
Schema of the connection for this SCIM configuration.
TenantName string
Name of the tenant for this SCIM configuration.
UserIdAttribute string
User ID attribute for generation unique of user ids. If user_id_attribute is set, mapping must be set as well. Defaults to userName for SAML connections and externalId for OIDC connections.
ConnectionId Changes to this property will trigger replacement. string
ID of the connection for this SCIM configuration.
ConnectionName string
Name of the connection for this SCIM configuration.
Mappings []ConnectionScimConfigurationMappingArgs
Mapping between Auth0 attributes and SCIM attributes. If user_id_attribute is set, mapping must be set as well.
Strategy string
Schema of the connection for this SCIM configuration.
TenantName string
Name of the tenant for this SCIM configuration.
UserIdAttribute string
User ID attribute for generation unique of user ids. If user_id_attribute is set, mapping must be set as well. Defaults to userName for SAML connections and externalId for OIDC connections.
connectionId Changes to this property will trigger replacement. String
ID of the connection for this SCIM configuration.
connectionName String
Name of the connection for this SCIM configuration.
mappings List<ConnectionScimConfigurationMapping>
Mapping between Auth0 attributes and SCIM attributes. If user_id_attribute is set, mapping must be set as well.
strategy String
Schema of the connection for this SCIM configuration.
tenantName String
Name of the tenant for this SCIM configuration.
userIdAttribute String
User ID attribute for generation unique of user ids. If user_id_attribute is set, mapping must be set as well. Defaults to userName for SAML connections and externalId for OIDC connections.
connectionId Changes to this property will trigger replacement. string
ID of the connection for this SCIM configuration.
connectionName string
Name of the connection for this SCIM configuration.
mappings ConnectionScimConfigurationMapping[]
Mapping between Auth0 attributes and SCIM attributes. If user_id_attribute is set, mapping must be set as well.
strategy string
Schema of the connection for this SCIM configuration.
tenantName string
Name of the tenant for this SCIM configuration.
userIdAttribute string
User ID attribute for generation unique of user ids. If user_id_attribute is set, mapping must be set as well. Defaults to userName for SAML connections and externalId for OIDC connections.
connection_id Changes to this property will trigger replacement. str
ID of the connection for this SCIM configuration.
connection_name str
Name of the connection for this SCIM configuration.
mappings Sequence[ConnectionScimConfigurationMappingArgs]
Mapping between Auth0 attributes and SCIM attributes. If user_id_attribute is set, mapping must be set as well.
strategy str
Schema of the connection for this SCIM configuration.
tenant_name str
Name of the tenant for this SCIM configuration.
user_id_attribute str
User ID attribute for generation unique of user ids. If user_id_attribute is set, mapping must be set as well. Defaults to userName for SAML connections and externalId for OIDC connections.
connectionId Changes to this property will trigger replacement. String
ID of the connection for this SCIM configuration.
connectionName String
Name of the connection for this SCIM configuration.
mappings List<Property Map>
Mapping between Auth0 attributes and SCIM attributes. If user_id_attribute is set, mapping must be set as well.
strategy String
Schema of the connection for this SCIM configuration.
tenantName String
Name of the tenant for this SCIM configuration.
userIdAttribute String
User ID attribute for generation unique of user ids. If user_id_attribute is set, mapping must be set as well. Defaults to userName for SAML connections and externalId for OIDC connections.

Supporting Types

ConnectionScimConfigurationMapping
, ConnectionScimConfigurationMappingArgs

Auth0 This property is required. string
The field location in the Auth0 schema.
Scim This property is required. string
The field location in the SCIM schema.
Auth0 This property is required. string
The field location in the Auth0 schema.
Scim This property is required. string
The field location in the SCIM schema.
auth0 This property is required. String
The field location in the Auth0 schema.
scim This property is required. String
The field location in the SCIM schema.
auth0 This property is required. string
The field location in the Auth0 schema.
scim This property is required. string
The field location in the SCIM schema.
auth0 This property is required. str
The field location in the Auth0 schema.
scim This property is required. str
The field location in the SCIM schema.
auth0 This property is required. String
The field location in the Auth0 schema.
scim This property is required. String
The field location in the SCIM schema.

Import

This resource can be imported by specifying the connection ID

Example:

$ pulumi import auth0:index/connectionScimConfiguration:ConnectionScimConfiguration my_conn_scim_conf "con_XXXXX"
Copy

To learn more about importing existing cloud resources, see Importing resources.

Package Details

Repository
Auth0 pulumi/pulumi-auth0
License
Apache-2.0
Notes
This Pulumi package is based on the auth0 Terraform Provider.