using Auth0.ManagementApi;
using System.Threading.Tasks;

public partial class Examples
{
    public async Task Example() {
        var client = new ManagementApiClient(
            token: "<token>",
            clientOptions: new ClientOptions { BaseUrl = "https://{YOUR_DOMAIN}/api/v2" }
        );

        await client.CustomDomains.UpdateAsync(
            id: "id",
            request: new UpdateCustomDomainRequestContent()
        );
    }

}

package example

import (
    context "context"

    management "github.com/auth0/go-auth0/v3/management"
    client "github.com/auth0/go-auth0/v3/management/client"
    option "github.com/auth0/go-auth0/v3/management/option"
)

func do() {
    mgmt, err := client.New(
        "{YOUR_DOMAIN}",
        option.WithToken(
            "<token>",
        ),
    )
    if err != nil {
        return
    }
    request := &management.UpdateCustomDomainRequestContent{}
    mgmt.CustomDomains.Update(
        context.TODO(),
        "id",
        request,
    )
}

package com.example.usage;

import com.auth0.client.mgmt.ManagementApi;
import com.auth0.client.mgmt.types.UpdateCustomDomainRequestContent;

public class Example {
    public static void main(String[] args) {
        ManagementApi client = ManagementApi
            .builder()
            .domain("{YOUR_DOMAIN}")
            .token("<token>")
            .build();

        client.customDomains().update(
            "id",
            UpdateCustomDomainRequestContent
                .builder()
                .build()
        );
    }
}

<?php

namespace Example;

use Auth0\SDK\API\Management\Wrapper\ManagementClient;
use Auth0\SDK\API\Management\Wrapper\ManagementClientOptions;
use Auth0\SDK\API\Management\CustomDomains\Requests\UpdateCustomDomainRequestContent;

$client = new ManagementClient(new ManagementClientOptions(
    domain: '{YOUR_DOMAIN}',
    token: '<token>',
));
$client->customDomains->update(
    'id',
    new UpdateCustomDomainRequestContent([]),
);

import { ManagementClient } from "auth0";

async function main() {
    const client = new ManagementClient({
        domain: "{YOUR_DOMAIN}",
        token: "<token>",
    });
    await client.customDomains.update("id", {});
}
main();

import { ManagementClient } from "auth0";

async function main() {
    const client = new ManagementClient({
        domain: "{YOUR_DOMAIN}",
        token: "<token>",
    });
    await client.customDomains.update("id", {});
}
main();

curl --request PATCH \
  --url https://{tenantDomain}/api/v2/custom-domains/{id} \
  --header 'Authorization: Bearer <token>' \
  --header 'Content-Type: application/json' \
  --data '
{
  "custom_client_ip_header": "x-forwarded-for",
  "domain_metadata": {},
  "relying_party_identifier": "<string>",
  "tls_policy": "recommended"
}
'

{
  "custom_domain_id": "cd_0000000000000001",
  "domain": "login.mycompany.com",
  "primary": false,
  "status": "ready",
  "type": "self_managed_certs",
  "verification": {
    "error_msg": "<string>",
    "last_verified_at": "<string>",
    "methods": [
      {
        "name": "txt",
        "record": "auth0-domain-verification=...",
        "domain": "_cf-custom-hostname.login.mycompany.com"
      }
    ]
  },
  "certificate": {
    "error_msg": "<string>",
    "renews_before": "<string>"
  },
  "custom_client_ip_header": "<string>",
  "domain_metadata": {},
  "is_default": false,
  "relying_party_identifier": "<string>",
  "tls_policy": "recommended"
}

Mettre à jour les domaines personnalisés par ID

deprecated

Mettre à jour un domaine personnalisé.

Voici les attributs qui peuvent être mis à jour :

custom_client_ip_header
tls_policy

Mise à jour de CUSTOM_CLIENT_IP_HEADER pour un domaine personnalisé

Pour mettre à jour custom_client_ip_header d’un domaine, le corps de la requête à envoyer doit être :

{ "custom_client_ip_header": "cf-connecting-ip" }

Mise à jour de TLS_POLICY pour un domaine personnalisé

Pour mettre à jour tls_policy d’un domaine, le corps de la requête à envoyer doit être :

{ "tls_policy": "recommended" }

Politiques TLS :

recommended - pour une utilisation moderne, cela comprend uniquement TLS 1.2

Points à considérer :

Les suites de chiffrement et les protocoles TLS disponibles dans chaque politique TLS suivent les recommandations de l’industrie et peuvent être mis à jour à l’occasion.
La politique TLS compatible n’est plus prise en charge.

PATCH

https://{tenantDomain}/api/v2

custom-domains

{id}

using Auth0.ManagementApi;
using System.Threading.Tasks;

public partial class Examples
{
    public async Task Example() {
        var client = new ManagementApiClient(
            token: "<token>",
            clientOptions: new ClientOptions { BaseUrl = "https://{YOUR_DOMAIN}/api/v2" }
        );

        await client.CustomDomains.UpdateAsync(
            id: "id",
            request: new UpdateCustomDomainRequestContent()
        );
    }

}

package example

import (
    context "context"

    management "github.com/auth0/go-auth0/v3/management"
    client "github.com/auth0/go-auth0/v3/management/client"
    option "github.com/auth0/go-auth0/v3/management/option"
)

func do() {
    mgmt, err := client.New(
        "{YOUR_DOMAIN}",
        option.WithToken(
            "<token>",
        ),
    )
    if err != nil {
        return
    }
    request := &management.UpdateCustomDomainRequestContent{}
    mgmt.CustomDomains.Update(
        context.TODO(),
        "id",
        request,
    )
}

package com.example.usage;

import com.auth0.client.mgmt.ManagementApi;
import com.auth0.client.mgmt.types.UpdateCustomDomainRequestContent;

public class Example {
    public static void main(String[] args) {
        ManagementApi client = ManagementApi
            .builder()
            .domain("{YOUR_DOMAIN}")
            .token("<token>")
            .build();

        client.customDomains().update(
            "id",
            UpdateCustomDomainRequestContent
                .builder()
                .build()
        );
    }
}

<?php

namespace Example;

use Auth0\SDK\API\Management\Wrapper\ManagementClient;
use Auth0\SDK\API\Management\Wrapper\ManagementClientOptions;
use Auth0\SDK\API\Management\CustomDomains\Requests\UpdateCustomDomainRequestContent;

$client = new ManagementClient(new ManagementClientOptions(
    domain: '{YOUR_DOMAIN}',
    token: '<token>',
));
$client->customDomains->update(
    'id',
    new UpdateCustomDomainRequestContent([]),
);

import { ManagementClient } from "auth0";

async function main() {
    const client = new ManagementClient({
        domain: "{YOUR_DOMAIN}",
        token: "<token>",
    });
    await client.customDomains.update("id", {});
}
main();

import { ManagementClient } from "auth0";

async function main() {
    const client = new ManagementClient({
        domain: "{YOUR_DOMAIN}",
        token: "<token>",
    });
    await client.customDomains.update("id", {});
}
main();

curl --request PATCH \
  --url https://{tenantDomain}/api/v2/custom-domains/{id} \
  --header 'Authorization: Bearer <token>' \
  --header 'Content-Type: application/json' \
  --data '
{
  "custom_client_ip_header": "x-forwarded-for",
  "domain_metadata": {},
  "relying_party_identifier": "<string>",
  "tls_policy": "recommended"
}
'

{
  "custom_domain_id": "cd_0000000000000001",
  "domain": "login.mycompany.com",
  "primary": false,
  "status": "ready",
  "type": "self_managed_certs",
  "verification": {
    "error_msg": "<string>",
    "last_verified_at": "<string>",
    "methods": [
      {
        "name": "txt",
        "record": "auth0-domain-verification=...",
        "domain": "_cf-custom-hostname.login.mycompany.com"
      }
    ]
  },
  "certificate": {
    "error_msg": "<string>",
    "renews_before": "<string>"
  },
  "custom_client_ip_header": "<string>",
  "domain_metadata": {},
  "is_default": false,
  "relying_party_identifier": "<string>",
  "tls_policy": "recommended"
}

Autorisations

Authorization

string

header

requis

Bearer authentication header of the form Bearer <token>, where <token> is your auth token.

Paramètres de chemin

string

requis

L’ID du domaine personnalisé à mettre à jour

Corps

custom_client_ip_header

enum<string> | null

défaut:x-forwarded-for

L’en-tête HTTP à utiliser pour récupérer l’adresse IP du client

Options disponibles:

true-client-ip,

cf-connecting-ip,

x-forwarded-for,

x-azure-clientip,

domain_metadata

object

Métadonnées de domaine associées au domaine personnalisé, sous la forme d’un objet avec des valeurs de type chaîne (max. 255 caractères). Un maximum de 10 propriétés de métadonnées de domaine est autorisé.

Show child attributes

relying_party_identifier

string<hostname> | null

ID de la partie de confiance (rpId) à utiliser pour les clés d’accès sur ce domaine personnalisé. Définissez-la à null pour supprimer le rpId et revenir à l’utilisation du domaine complet.

Maximum string length: 255

tls_policy

enum<string>

défaut:recommended

recommended inclut TLS 1.2

Options disponibles:

recommended

Réponse

Domaine personnalisé mis à jour.

custom_domain_id

string

défaut:cd_0000000000000001

requis

ID du domaine personnalisé.

domain

string

défaut:login.mycompany.com

requis

Nom de domaine.

primary

boolean

défaut:false

requis

Indique s’il s’agit d’un domaine principal (true) ou non (false).

status

enum<string>

défaut:ready

requis

Statut de la configuration du domaine personnalisé. Peut être failed, pending_verification ou ready.

Options disponibles:

pending_verification,

ready,

failed

type

enum<string>

défaut:self_managed_certs

requis

Type de provisionnement du domaine personnalisé. Peut être auth0_managed_certs ou self_managed_certs.

Options disponibles:

auth0_managed_certs,

self_managed_certs

verification

object

requis

Paramètres de vérification du domaine.

Show child attributes

certificate

object

Renseignements sur le certificat. Cet objet s’applique uniquement aux domaines personnalisés avec des certificats gérés par Auth0.

Show child attributes

custom_client_ip_header

string | null

L’en-tête HTTP à utiliser pour récupérer l’adresse IP du client

domain_metadata

object

Show child attributes

is_default

boolean

défaut:false

Indique s’il s’agit du domaine personnalisé par défaut (true) ou non (false).

relying_party_identifier

string<hostname>

ID de la partie de confiance (rpId) à utiliser pour les clés d’accès sur ce domaine personnalisé. S’il n’est pas présent, le domaine complet sera utilisé.

tls_policy

string

défaut:recommended

La politique de version TLS