Automatiser la gestion des tenants

Vous pouvez gérer les tenants Logto Cloud de manière programmatique, y compris la création de tenants et la poursuite de la configuration sans passer par la Console.

Ceci est utile lorsque vous devez approvisionner des tenants depuis votre propre parcours d'intégration, une plateforme interne, un agent IA ou une automatisation d'intégration.

Le flux d'automatisation est le suivant :

1. Utilisez un Logto Cloud Personal Access Token (PAT) pour appeler l'API Logto Cloud.
2. Créez un tenant avec POST /api/tenants.
3. Lisez les identifiants de l'application Machine à machine (M2M) par défaut dans la réponse de création.
4. Utilisez l'application M2M par défaut pour obtenir un jeton d’accès Management API pour le nouveau tenant.
5. Appelez la Management API du nouveau tenant pour continuer l'approvisionnement des applications, utilisateurs, rôles, ressources, organisations et autres paramètres.

Avant de commencer

Préparez les valeurs suivantes :

Variable	Description
CLOUD_API_ENDPOINT	Le point de terminaison de l'API Logto Cloud. Pour Logto Cloud, utilisez https://cloud.logto.io.
LOGTO_CLOUD_PAT	Un PAT pour votre compte Logto Cloud.
TENANT_NAME	Le nom d'affichage du tenant à créer.
TENANT_TAG	Le type de tenant. Utilisez development ou production.
REGION_NAME	L'identifiant de la région pour le tenant.

Définissez-les comme variables d'environnement :

export CLOUD_API_ENDPOINT="https://cloud.logto.io"
export LOGTO_CLOUD_PAT="<logto-cloud-pat>"
export TENANT_NAME="Mon tenant automatisé"
export TENANT_TAG="development"
export REGION_NAME="<region-name>"

Obtenir les régions disponibles

Avant de créer un tenant, récupérez les régions disponibles pour votre compte Logto Cloud :

curl "$CLOUD_API_ENDPOINT/api/me/regions" \
  -H "Authorization: Bearer $LOGTO_CLOUD_PAT"

La réponse contient les régions disponibles. Utilisez la valeur name comme REGION_NAME lors de la création du tenant.

Exemple de réponse :

{
  "regions": [
    {
      "name": "EU",
      "displayName": "Europe"
    },
    {
      "name": "US",
      "displayName": "United States"
    }
  ]
}

Créer un tenant

Appelez POST /api/tenants avec le Logto Cloud PAT :

curl "$CLOUD_API_ENDPOINT/api/tenants" \
  -X POST \
  -H "Authorization: Bearer $LOGTO_CLOUD_PAT" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "'"$TENANT_NAME"'",
    "tag": "'"$TENANT_TAG"'",
    "regionName": "'"$REGION_NAME"'"
  }'

La réponse inclut le tenant créé et une application M2M par défaut. L'application M2M est créée dans le nouveau tenant et a accès à la Management API du tenant.

Exemple de réponse :

{
  "id": "new-tenant-id",
  "name": "Mon tenant automatisé",
  "tag": "development",
  "indicator": "https://new-tenant-id.logto.app",
  "regionName": "EU",
  "defaultApplication": {
    "id": "default-m2m-app-id",
    "secret": "default-m2m-app-secret"
  }
}

Enregistrez les valeurs nécessaires pour l'étape suivante :

export TENANT_ID="<response.id>"
export TENANT_ENDPOINT="<response.indicator>"
export DEFAULT_M2M_APP_ID="<response.defaultApplication.id>"
export DEFAULT_M2M_APP_SECRET="<response.defaultApplication.secret>"

astuce:

Un tenant créé avec tag: "production" commence sur le plan Free. Pour le passer au plan Pro depuis le même script, voir Souscrire un tenant au plan Pro. Un tenant de développement, comme dans cet exemple, ne peut pas être souscrit via l'API.

Obtenir un jeton d’accès Management API pour le nouveau tenant

Utilisez les identifiants de l'application M2M par défaut pour demander un jeton d’accès au nouveau tenant :

curl "$TENANT_ENDPOINT/oidc/token" \
  -X POST \
  -u "$DEFAULT_M2M_APP_ID:$DEFAULT_M2M_APP_SECRET" \
  -H "Content-Type: application/x-www-form-urlencoded" \
  -d "grant_type=client_credentials" \
  -d "resource=$TENANT_ENDPOINT/api" \
  -d "scope=all"

Exemple de réponse :

{
  "access_token": "eyJ...",
  "expires_in": 3600,
  "token_type": "Bearer",
  "scope": "all"
}

Enregistrez le jeton d’accès :

export MANAGEMENT_API_ACCESS_TOKEN="<response.access_token>"

Continuer l'approvisionnement du nouveau tenant

Utilisez le jeton d’accès Management API pour appeler la Management API du nouveau tenant.

Par exemple, lister les applications :

curl "$TENANT_ENDPOINT/api/applications" \
  -H "Authorization: Bearer $MANAGEMENT_API_ACCESS_TOKEN"

Ou créer une application :

curl "$TENANT_ENDPOINT/api/applications" \
  -X POST \
  -H "Authorization: Bearer $MANAGEMENT_API_ACCESS_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Mon application web",
    "type": "SPA",
    "oidcClientMetadata": {
      "redirectUris": ["https://example.com/callback"],
      "postLogoutRedirectUris": ["https://example.com"]
    }
  }'

À ce stade, votre automatisation peut continuer avec n'importe quelle opération Management API, comme la création d'utilisateurs, d'applications, de ressources API, de rôles, d'organisations, de connecteurs ou de paramètres d'expérience de connexion.

Exemple d'automatisation complète

L'exemple Node.js suivant crée un tenant, échange les identifiants M2M par défaut retournés contre un jeton d’accès Management API, et liste les applications dans le nouveau tenant :

const cloudApiEndpoint = 'https://cloud.logto.io';
const logtoCloudPat = process.env.LOGTO_CLOUD_PAT;

const createTenantResponse = await fetch(`${cloudApiEndpoint}/api/tenants`, {
  method: 'POST',
  headers: {
    authorization: `Bearer ${logtoCloudPat}`,
    'content-type': 'application/json',
  },
  body: JSON.stringify({
    name: 'Mon tenant automatisé',
    tag: 'development',
    regionName: 'EU',
  }),
});

if (!createTenantResponse.ok) {
  throw new Error(`Failed to create tenant: ${await createTenantResponse.text()}`);
}

const tenant = await createTenantResponse.json();
const tenantEndpoint = tenant.indicator;
const { id: appId, secret: appSecret } = tenant.defaultApplication;

const tokenResponse = await fetch(`${tenantEndpoint}/oidc/token`, {
  method: 'POST',
  headers: {
    authorization: `Basic ${Buffer.from(`${appId}:${appSecret}`).toString('base64')}`,
    'content-type': 'application/x-www-form-urlencoded',
  },
  body: new URLSearchParams({
    grant_type: 'client_credentials',
    resource: `${tenantEndpoint}/api`,
    scope: 'all',
  }),
});

if (!tokenResponse.ok) {
  throw new Error(`Failed to get Management API token: ${await tokenResponse.text()}`);
}

const { access_token: managementApiAccessToken } = await tokenResponse.json();

const applicationsResponse = await fetch(`${tenantEndpoint}/api/applications`, {
  headers: {
    authorization: `Bearer ${managementApiAccessToken}`,
  },
});

if (!applicationsResponse.ok) {
  throw new Error(`Failed to list applications: ${await applicationsResponse.text()}`);
}

const applications = await applicationsResponse.json();

console.log({ tenantId: tenant.id, applications });

Ressources associées

• Souscrire un tenant au plan Pro
• Personal access token
• Interagir avec Management API
• Démarrage rapide Machine-to-machine