Mandantenverwaltung automatisieren

Du kannst Logto Cloud-Mandanten programmatisch verwalten, einschließlich der Erstellung von Mandanten und der weiteren Konfiguration, ohne zur Konsole 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 Management API Zugangstoken für den neuen Mandanten zu erhalten.
5. Rufe die Management API des neuen Mandanten auf, um die Bereitstellung von Anwendungen, Benutzern, Rollen, Ressourcen, Organisationen und weiteren Einstellungen fortzusetzen.

Bevor du beginnst

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

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 eine Anwendung 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

• Personal access token
• Mit Management API interagieren
• Maschine-zu-Maschine Schnellstart