chore: update translations and generated content

i18n/de/docusaurus-plugin-content-docs/current/logto-cloud/README.mdx

@@ -3,6 +3,7 @@ import Developer from '@site/src/assets/developer.svg';
 import TenantMemberManagement from '@site/src/assets/gear.svg';
 import PricingAndBilling from '@site/src/assets/key.svg';
 import McpIcon from '@site/src/assets/mcp.svg';
+import TenantAutomation from '@site/src/assets/robot.svg';
 import CustomDomains from '@site/src/assets/search.svg';
 import SystemLimit from '@site/src/assets/security.svg';
 
@@ -41,7 +42,7 @@ Wenn du Fragen zu Cloud-Diensten hast und zusätzliche Unterstützung benötigst
       label: 'Mandanten-Mitgliederverwaltung',
       href: '/logto-cloud/tenant-member-management',
       description:
-        'Der Mandanten-Admin kann Mitglieder einladen und verwalten sowie deren Rollen aktualisieren.',
+        'Der Mandanten-Admin kann Mitglieder einladen, verwalten und deren Rollen aktualisieren.',
       customProps: {
         icon: <TenantMemberManagement />,
       },
@@ -51,7 +52,7 @@ Wenn du Fragen zu Cloud-Diensten hast und zusätzliche Unterstützung benötigst
       label: 'Eigene Domains',
       href: '/logto-cloud/custom-domain',
       description:
-        'Verwende deine eigene Domain für deinen Logto-Mandanten, um ein konsistentes Branding in deiner Endbenutzererfahrung zu gewährleisten.',
+        'Nutze deine eigene Domain für deinen Logto-Mandanten, um ein konsistentes Branding in der Endbenutzererfahrung zu gewährleisten.',
       customProps: {
         icon: <CustomDomains />,
       },
@@ -75,6 +76,16 @@ Wenn du Fragen zu Cloud-Diensten hast und zusätzliche Unterstützung benötigst
         icon: <SystemLimit />,
       },
     },
+    {
+      type: 'link',
+      label: 'Mandantenverwaltung automatisieren',
+      href: '/logto-cloud/automate-tenant-creation',
+      description:
+        'Erstelle und verwalte Mandanten programmatisch mit Logto Cloud API und Management API.',
+      customProps: {
+        icon: <TenantAutomation />,
+      },
+    },
     {
       type: 'link',
       label: 'Logto MCP Server',

i18n/de/docusaurus-plugin-content-docs/current/logto-cloud/automate-tenant-creation.mdx

@@ -0,0 +1,242 @@
+---
+id: automate-tenant-creation
+title: Mandantenverwaltung automatisieren
+sidebar_position: 8
+---
+
+# 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 \{#before-you-start}
+
+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:
+
+```bash
+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 \{#get-available-regions}
+
+Bevor du einen Mandanten erstellst, rufe die für dein Logto Cloud-Konto verfügbaren Regionen ab:
+
+```bash
+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:
+
+```json
+{
+  "regions": [
+    {
+      "name": "EU",
+      "displayName": "Europe"
+    },
+    {
+      "name": "US",
+      "displayName": "United States"
+    }
+  ]
+}
+```
+
+## Einen Mandanten erstellen \{#create-a-tenant}
+
+Rufe `POST /api/tenants` mit dem Logto Cloud PAT auf:
+
+```bash
+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:
+
+```json
+{
+  "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:
+
+```bash
+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 \{#get-a-management-api-access-token-for-the-new-tenant}
+
+Verwende die Standard-M2M-Anwendungsdaten, um ein Zugangstoken vom neuen Mandanten anzufordern:
+
+```bash
+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:
+
+```json
+{
+  "access_token": "eyJ...",
+  "expires_in": 3600,
+  "token_type": "Bearer",
+  "scope": "all"
+}
+```
+
+Speichere das Zugangstoken:
+
+```bash
+export MANAGEMENT_API_ACCESS_TOKEN="<response.access_token>"
+```
+
+## Die Bereitstellung des neuen Mandanten fortsetzen \{#continue-provisioning-the-new-tenant}
+
+Verwende das Management API Zugangstoken, um die Management API des neuen Mandanten aufzurufen.
+
+Zum Beispiel, um Anwendungen aufzulisten:
+
+```bash
+curl "$TENANT_ENDPOINT/api/applications" \
+  -H "Authorization: Bearer $MANAGEMENT_API_ACCESS_TOKEN"
+```
+
+Oder eine Anwendung erstellen:
+
+```bash
+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 \{#full-automation-example}
+
+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:
+
+```js
+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 \{#related-resources}
+
+- [Personal access token](/user-management/personal-access-token)
+- [Mit Management API interagieren](/integrate-logto/interact-with-management-api)
+- [Maschine-zu-Maschine Schnellstart](/quick-starts/m2m)