> For the complete documentation index, see [llms.txt](https://docs.realmjoin.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.realmjoin.com/de/bereitstellung/architecture-overview.md).

# Architekturübersicht

Ein Überblick über die RealmJoin-Architektur: das Cloud-Backend, wie verwaltete Geräte und Administratoren verbunden werden und welche Ressourcen RealmJoin in Ihrem eigenen Microsoft-Tenant verwendet.

RealmJoin ist ein cloud-natives, mandantenfähiges SaaS und der **der Begleiter für Application Lifecycle and Management für Microsoft Intune**. Es verwaltet Anwendungsbereitstellung, Benutzer-/Gruppen-/Geräteverwaltung und Prozessautomatisierung in Ihrem Entra ID Tenant — **ohne lokale Server oder lokale Infrastruktur**. Alle Backend-Dienste werden von glueckkanja in **Microsoft Azure, gehostet in Europa**.

RealmJoin deckt drei Bereiche ab:

* **Anwendungsverwaltung** – Paketierung, Bereitstellung, einen Self-Service-Katalog und Software-Reporting.
* **Benutzer-, Gruppen- und Geräteverwaltung** – eine einzige, einheitliche Ansicht, die Daten aus Intune, Entra ID, Microsoft Defender, Windows Autopilot und Anmeldeprotokollen kombiniert.
* **Prozessautomatisierung** – Runbooks, die in *Ihrem eigenen* Azure Automation-Konto ausgeführt werden.

## Das Gesamtbild

```mermaid
%%{init: {"flowchart": {"htmlLabels": false, "nodeSpacing": 55, "rankSpacing": 90}} }%%
flowchart LR
    Admin["Administratoren"]
    Integr["Ihre Integrationen"]
    Device["Verwaltete Geräte<br/>(RealmJoin Agent)"]

    subgraph RJ["RealmJoin-Backend - Azure (Europa)"]
        direction TB
        Portal["RealmJoin Portal"]
        CustApi["Customer-API"]
        ClientApi["Client-API"]
        FD{{"Azure Front Door"}}
        CDN["CDN und Paketserver"]
        Core[("Backend-Dienste<br/>und Datenbanken")]
    end

    subgraph Tenant["Ihr Microsoft Tenant"]
        direction TB
        Graph["Entra ID / Intune / Defender<br/>(über Microsoft Graph)"]
        subgraph AzureRes["Ihre Azure-Ressourcen"]
            direction TB
            KV["Key Vault<br/>(LAPS-Kennwörter)"]
            Autom["Azure Automation<br/>(Runbooks)"]
            LA["Log Analytics<br/>(Protokolle)"]
        end
    end

    Admin --> Portal
    Integr --> CustApi
    Device --> ClientApi
    Device --> FD
    FD --> CDN

    Portal --> Core
    ClientApi --> Core
    CustApi --> Core

    Core -->|Zugriff mit geringsten Rechten| Graph
    Core --> KV
    Core --> Autom
    Core --> LA
```

RealmJoin verbindet sich mit Ihrem Tenant über **Entra ID-Anwendungen mit geringsten Rechten** denen Sie während des Onboardings zustimmen. Jede Aktion, die das Backend ausführt, wird durch RealmJoin's **internes Role-Based Access Control (RBAC)** Modell gefiltert, das Entra-Gruppen- und Rollenmitgliedschaften auswertet.

## Backend-Komponenten

Das Backend ist eine Reihe unabhängig bereitgestellter Dienste, die in Microsoft Azure laufen:

| Komponente              | Zweck                                                                                                                         | Wer sich damit verbindet                                                                       |
| ----------------------- | ----------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------- |
| **RealmJoin-Portal**    | Die Weboberfläche, die Administratoren verwenden, um Anwendungen, Geräte, Benutzer, Gruppen und Automatisierung zu verwalten. | Administratoren, über die Anmeldung mit Entra ID (OAuth 2.0 / OpenID Connect).                 |
| **Client-API**          | Der Endpunkt, mit dem der optionale RealmJoin Agent auf jedem Gerät kommuniziert.                                             | Verwaltete Geräte, authentifiziert durch die Geräteidentität (Entra-Token + Gerätezertifikat). |
| **Customer-API**        | Eine programmatische API für Ihre eigenen Integrationen und Automatisierung.                                                  | Ihre Systeme und Tools, die einen kundenspezifischen API-Schlüssel verwenden.                  |
| **CDN und Paketserver** | Liefert Anwendungspakete und Inhalte an Geräte.                                                                               | Verwaltete Geräte.                                                                             |

Dahinter betreibt RealmJoin Hintergrundverarbeitungsdienste und speichert Daten in verwalteten Azure-Datenbanken und -Speichern. Nach außen gerichtete interne Dienste (wie Abrechnung und Hintergrundaufträge) sind über das Internet nicht erreichbar.

## Der RealmJoin Agent

Der RealmJoin Agent ist eine **optional** Windows-Komponente. Wenn er installiert ist,

* meldet er den Gerätestatus regelmäßig an die Client-API,
* ruft eine **signierte** Gerätekonfiguration ab (Software- und Richtlinienzuweisungen),
* führt lokal eine **Sicherheitsbewertung** (Verschlüsselung, Patch-Stand, Firewall, Antivirenprogramm) aus, bevor obligatorische Apps angewendet werden,
* liefert Anwendungen effizient mithilfe einer erweiterten Chocolatey-Engine plus **BranchCache** Peer-to-Peer-Verteilung,
* unterstützt **LAPS** (lokales Administratorkennwort) — Kennwörter werden auf dem Gerät generiert und gespeichert in **Ihrem eigenen Azure Key Vault**.

```mermaid
sequenceDiagram
    participant Device as RealmJoin Agent
    participant API as Client-API
    participant CDN as RealmJoin CDN

    Device->>API: Status melden & Konfiguration anfordern
    API-->>Device: Signierte Konfiguration (Apps & Richtlinien)
    Device->>Device: Sicherheitsbewertung
    Device->>CDN: Zugewiesene Pakete herunterladen
    Note over Device: Peer-to-Peer-Paketfreigabe über BranchCache
```

Weitere Details zur Paketbereitstellung und zu BranchCache finden Sie unter [Infrastrukturüberlegungen](https://docs.realmjoin.com/de/bereitstellung/infrastructure.md).

## Prozessautomatisierung (Runbooks)

Runbooks laufen in **Ihrem eigenen Azure Automation-Konto** — nicht im Backend von RealmJoin. RealmJoin hält Ihre Runbook-Bibliothek mit einem kuratierten, offenen GitHub-Repository synchron und verwaltet sowie überwacht die Jobausführung über das Portal. Die Runbooks arbeiten über die **verwaltete Identität**des Automation-Kontos, sodass die verwendeten Berechtigungen vollständig unter Ihrer Kontrolle bleiben.

Siehe [Verbindung mit Azure Automation](https://docs.realmjoin.com/de/automatisierung/connecting-azure-automation.md) und [Runbooks](https://docs.realmjoin.com/de/automatisierung/runbooks.md) für weitere Informationen.

## Anwendungsbereitstellung

Pakete werden von RealmJoin's Packaging-Pipeline erzeugt und über den RealmJoin **CDN** und **Paketserver**, mit georepliziertem Speicher und BranchCache für eine effiziente Verteilung im Netzwerk. Anwendungen können entweder über **RealmJoin Deployment** (über den Agent) oder als **Intune Deployment** (ein intunewin-Paket, das in Ihren Tenant bereitgestellt wird).

## Ressourcen in Ihrer eigenen Umgebung

Mehrere Funktionen verwenden Ressourcen in **Ihrem eigenen Microsoft Tenant und Azure-Abonnement**, sodass sensible Daten unter Ihrer Kontrolle bleiben:

* **Azure Key Vault** – speichert die auf Ihren Geräten generierten lokalen LAPS-Administratorkennwörter.
* **Azure Automation** – führt Ihre Runbooks unter einer von Ihnen kontrollierten verwalteten Identität aus.
* **Log Analytics** – speichert Audit-Logs und archivierte Runbook-Logs.

RealmJoin greift auf diese — sowie auf Entra ID, Intune und Defender über Microsoft Graph — nur mit den Berechtigungen mit den geringsten Rechten zu, die Sie während des Onboardings gewähren. Siehe [Erforderliche Portalberechtigungen](https://docs.realmjoin.com/de/bereitstellung/required-permissions.md) für die vollständige Liste.

## Sicherheit, Hosting und Datenresidenz

* **Hosting:** Alle Backend-Dienste laufen in **Microsoft Azure**, hauptsächlich in der **West Europe** Region mit Backup in **North Europe**. **Kundendaten verlassen Europa nicht.**
* **Bereitstellung:** Das Portal und die APIs werden direkt über HTTPS erreicht. Anwendungspakete und Inhalte werden über den RealmJoin **CDN**, vorangestellt von **Azure Front Door** für global lastverteilte Verteilung.
* **Verschlüsselung während der Übertragung:** Alle Verbindungen verwenden HTTPS/TLS.
* **Identität:** Der Administratorzugriff verwendet Entra ID (OAuth 2.0 / OpenID Connect); Geräte authentifizieren sich mit ihrer Entra-Geräteidentität und einem Gerätezertifikat; programmatische APIs verwenden kundenspezifische Schlüssel.
* **Tenant-Isolierung:** Die Daten jedes Kunden sind getrennt, und alle Backend-Codepfade arbeiten in einem mandantenspezifischen Kontext.
* **Prinzip der geringsten Rechte:** Die Entra-Anwendungen von RealmJoin fordern nur die Berechtigungen an, die für die von Ihnen aktivierten Funktionen benötigt werden, und alle Aktionen werden durch das interne RBAC-Modell von RealmJoin gesteuert.
* **Ausfallsicherheit:** Redundante Infrastruktur mit automatischem Failover und punktgenauer Datenbankwiederherstellung; die Infrastruktur ist vollständig als Code definiert (Terraform).

{% hint style="info" %}
Extern erreichbare Endpunkte sind das **Portal, die Client-API, die Customer-API, CDN und Package Server**. Die vollständige Liste der Hosts, die in Ihrer Firewall zugelassen werden müssen, finden Sie unter [Infrastrukturüberlegungen](https://docs.realmjoin.com/de/bereitstellung/infrastructure.md). Weitere Details zur Datenverarbeitung und Tenant-Trennung finden Sie unter [Sicherheit & Datenschutz](https://docs.realmjoin.com/de/sicherheit-and-datenschutz/security-and-privacy.md).
{% endhint %}


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.realmjoin.com/de/bereitstellung/architecture-overview.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
