Docs Home Pulumi IaC Pulumi ESC Pulumi Cloud Packages Tutorials
  1. Packages
  2. Auth0 Provider
  3. API Docs
  4. ConnectionScimConfiguration
Auth0 v3.8.3 published on Wednesday, Nov 6, 2024 by Pulumi
pulumi/pulumi-auth0

auth0.ConnectionScimConfiguration

Explore with Pulumi AI

auth0 logo
Auth0 v3.8.3 published on Wednesday, Nov 6, 2024 by Pulumi
pulumi/pulumi-auth0

    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",
        },
    ],
});

    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",
        },
    ])

    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
	})
}

    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",
            },
        },
    });

});

    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());

    }
}

    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

    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 string
    The unique name of the resource.
    args ConnectionScimConfigurationArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    resource_name str
    The unique name of the resource.
    args 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 string
    The unique name of the resource.
    args ConnectionScimConfigurationArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args ConnectionScimConfigurationArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args 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",
});

    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"),
})

    var connectionScimConfigurationResource = new ConnectionScimConfiguration("connectionScimConfigurationResource", ConnectionScimConfigurationArgs.builder()
    .connectionId("string")
    .mappings(ConnectionScimConfigurationMappingArgs.builder()
        .auth0("string")
        .scim("string")
        .build())
    .userIdAttribute("string")
    .build());

    connection_scim_configuration_resource = auth0.ConnectionScimConfiguration("connectionScimConfigurationResource",
    connection_id="string",
    mappings=[{
        "auth0": "string",
        "scim": "string",
    }],
    user_id_attribute="string")

    const connectionScimConfigurationResource = new auth0.ConnectionScimConfiguration("connectionScimConfigurationResource", {
    connectionId: "string",
    mappings: [{
        auth0: "string",
        scim: "string",
    }],
    userIdAttribute: "string",
});

    type: auth0:ConnectionScimConfiguration
properties:
    connectionId: string
    mappings:
        - auth0: string
          scim: string
    userIdAttribute: string

    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 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 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 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 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 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 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)
    Resource lookup is not supported in YAML
    name
    The unique name of the resulting resource.
    id
    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
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    name
    The unique name of the resulting resource.
    id
    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
    The unique name of the resulting resource.
    id
    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
    The unique name of the resulting resource.
    id
    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 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 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 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 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 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 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 string
    The field location in the Auth0 schema.
    Scim string
    The field location in the SCIM schema.
    Auth0 string
    The field location in the Auth0 schema.
    Scim string
    The field location in the SCIM schema.
    auth0 String
    The field location in the Auth0 schema.
    scim String
    The field location in the SCIM schema.
    auth0 string
    The field location in the Auth0 schema.
    scim string
    The field location in the SCIM schema.
    auth0 str
    The field location in the Auth0 schema.
    scim str
    The field location in the SCIM schema.
    auth0 String
    The field location in the Auth0 schema.
    scim 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"

    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.
    auth0 logo
    Auth0 v3.8.3 published on Wednesday, Nov 6, 2024 by Pulumi
    pulumi/pulumi-auth0