Mandantenverwaltung automatisieren

Du kannst Logto Cloud-Mandanten programmatisch verwalten, einschließlich der Erstellung von Mandanten und der weiteren Konfiguration, ohne zur Console wechseln zu müssen.

Das ist nützlich, wenn du Mandanten aus deinem eigenen Onboarding-Flow, einer internen Plattform, einem KI-Agenten oder einer Integrationsautomatisierung bereitstellen musst.

Der Automatisierungsablauf ist:

1. Verwende ein Logto Cloud Personal Access Token (PAT), um die Logto Cloud API aufzurufen.
2. Erstelle einen Mandanten mit POST /api/tenants.
3. Lies die Standard-Maschine-zu-Maschine (M2M)-Anwendungsdaten aus der Antwort zur Erstellung aus.
4. Verwende die Standard-M2M-Anwendung, um ein Zugangstoken für die Management API des neuen Mandanten zu erhalten.
5. Rufe die Management API des neuen Mandanten auf, um Anwendungen, Benutzer, Rollen, Ressourcen, Organisationen und andere Einstellungen weiter bereitzustellen.

Ein PAT erstellen

Erstelle ein Personal Access Token (PAT) für dein Logto Cloud-Konto:

1. Klicke in der Logto Cloud Console oben rechts auf dein Avatar und wähle Profil.
2. Öffne die Seite Sicherheit.
3. Klicke unter Persönliche Zugriffstokens auf Neues Token erstellen.
4. Gib einen Namen ein und wähle ein Ablaufdatum von bis zu 365 Tagen, dann bestätige.

Das Token wird nur einmal angezeigt, direkt nachdem du es erstellt hast. Kopiere es und bewahre es an einem sicheren Ort auf, z. B. in einem Secret Manager. Du kannst es später nicht mehr einsehen.

Wir empfehlen ein Ablaufdatum von 90 Tagen und das Token vor Ablauf zu rotieren. Du kannst ein Token auf derselben Seite umbenennen oder widerrufen.

Das Widerrufen eines Tokens wird innerhalb von etwa einer Minute wirksam.

Ein PAT kann die Cloud API-Routen aufrufen, die die Berechtigung create:tenant oder manage:tenant:self erfordern:

• GET /api/me/regions, um die für dein Konto verfügbaren Regionen aufzulisten.
• POST /api/tenants, um einen Mandanten zu erstellen.
• GET /api/tenants, um deine Mandanten aufzulisten, sowie PATCH oder DELETE /api/tenants/{tenantId}, um einen umzubenennen oder zu löschen.
• POST /api/tenants/{tenantId}/subscription und die anderen Endpunkte unter /api/tenants/{tenantId}, um den Plan, Rechnungen und E-Mail-Protokolle eines Mandanten zu verwalten.

Routen, die die Berechtigung manage:account:self erfordern, wie Abrechnung, Lizenzen und Console SSO, benötigen eine interaktive Console-Sitzung und können nicht mit einem PAT aufgerufen werden.

Bevor du startest

Bereite die folgenden Werte vor:

Variable	Beschreibung
CLOUD_API_ENDPOINT	Der Logto Cloud API-Endpunkt. Für Logto Cloud verwende https://cloud.logto.io.
LOGTO_CLOUD_PAT	Ein PAT für dein Logto Cloud-Konto.
TENANT_NAME	Der Anzeigename des zu erstellenden Mandanten.
TENANT_TAG	Der Mandantentyp. Verwende development oder production.
REGION_NAME	Der Regionsbezeichner für den Mandanten.

Setze sie als Umgebungsvariablen:

export CLOUD_API_ENDPOINT="https://cloud.logto.io"
export LOGTO_CLOUD_PAT="<logto-cloud-pat>"
export TENANT_NAME="Mein automatisierter Mandant"
export TENANT_TAG="development"
export REGION_NAME="<region-name>"

Verfügbare Regionen abrufen

Bevor du einen Mandanten erstellst, rufe die für dein Logto Cloud-Konto verfügbaren Regionen ab:

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

Die Antwort enthält die verfügbaren Regionen. Verwende den Wert von name als REGION_NAME, wenn du den Mandanten erstellst.

Beispielantwort:

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

Einen Mandanten erstellen

Rufe POST /api/tenants mit dem Logto Cloud PAT auf:

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"'"
  }'

Die Antwort enthält den erstellten Mandanten und eine Standard-M2M-Anwendung. Die M2M-Anwendung wird im neuen Mandanten erstellt und hat Zugriff auf die Management API des Mandanten.

Beispielantwort:

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

Speichere die Werte, die du für den nächsten Schritt benötigst:

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>"

tipp:

Ein Mandant, der mit tag: "production" erstellt wird, startet im Free-Plan. Um ihn im selben Skript auf den Pro-Plan zu setzen, siehe Einen Mandanten auf den Pro-Plan abonnieren. Ein Entwicklungsmandant wie in diesem Beispiel kann nicht über die API abonniert werden.

Ein Management API Zugangstoken für den neuen Mandanten erhalten

Verwende die Standard-M2M-Anwendungsdaten, um ein Zugangstoken vom neuen Mandanten anzufordern:

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"

Beispielantwort:

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

Speichere das Zugangstoken:

export MANAGEMENT_API_ACCESS_TOKEN="<response.access_token>"

Die Bereitstellung des neuen Mandanten fortsetzen

Verwende das Management API Zugangstoken, um die Management API des neuen Mandanten aufzurufen.

Zum Beispiel, um Anwendungen aufzulisten:

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

Oder um eine Anwendung zu erstellen:

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

An diesem Punkt kann deine Automatisierung mit jeder Management API-Operation fortfahren, wie z. B. dem Erstellen von Benutzern, Anwendungen, API-Ressourcen, Rollen, Organisationen, Connectors oder Einstellungen für die Anmeldeerfahrung.

Vollständiges Automatisierungsbeispiel

Das folgende Node.js-Beispiel erstellt einen Mandanten, tauscht die zurückgegebenen Standard-M2M-Zugangsdaten gegen ein Management API Zugangstoken aus und listet Anwendungen im neuen Mandanten auf:

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: 'Mein automatisierter Mandant',
    tag: 'development',
    regionName: 'EU',
  }),
});

if (!createTenantResponse.ok) {
  throw new Error(`Fehler beim Erstellen des Mandanten: ${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(`Fehler beim Abrufen des Management API Tokens: ${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(`Fehler beim Auflisten der Anwendungen: ${await applicationsResponse.text()}`);
}

const applications = await applicationsResponse.json();

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

Verwandte Ressourcen

• Einen Mandanten auf den Pro-Plan abonnieren
• Personal Access Token
• Mit der Management API interagieren
• Maschine-zu-Maschine Schnellstart