Schritt-für-Schritt-Anleitung zu E-Mail-Benachrichtigungen mit EasyLife 365 Webhooks

Heute erkunden wir, wie man die Funktionalität von EasyLife 365 Collaboration mit Webhooks erweitert. Webhooks ermöglichen die Ausführung von benutzerdefiniertem Code in verschiedenen Phasen des Lifecycles eines Objekts. In dieser Anleitung erstellen wir eine Azure Functions-basierte Lösung, die über die Graph API E-Mail-Benachrichtigungen sendet, wenn ein Team mit einem bestimmten Template erstellt wird.

Einführung in EasyLife 365 Webhooks

Die EasyLife 365 Collaboration-Plattform unterstützt Webhooks an mehreren Punkten im Workflow:

• Während der Ressourcenbereitstellung (Teams, Gruppen, SharePoint-Sites, Gastkonten)
• Bei Metadatenänderungen an bestehenden Ressourcen
• Als Teil von Eskalationsaktionen in Richtlinien

Das ermöglicht den Aufbau ausgefeilter Automatisierungsworkflows, die sich in bestehende Systeme und Prozesse integrieren.

Komponenten und Einrichtung

Unsere Beispiellösung zeigt einen häufigen Webhook-Anwendungsfall: E-Mail-Benachrichtigungen senden, wenn neue Teams erstellt werden. Die Lösungsarchitektur besteht aus:

Azure-Komponenten

• Function App mit PowerShell-Laufzeit
• App Service Plan
• Storage Account für Queuing
• Application Insights für Monitoring

Funktions-Komponenten

Zwei Azure Functions, die zusammenarbeiten:

• mailrequest: HTTP-getriggerte Funktion, die Webhook-Anfragen von EasyLife empfängt und in eine Storage Queue schreibt
• mailqueue: Queue-getriggerte Funktion, die Nachrichten verarbeitet und E-Mails über die Graph API sendet

Diese Architektur gewährleistet zuverlässige Nachrichtenverarbeitung mit integrierten Wiederholungsmöglichkeiten über Azure Storage Queues.

Voraussetzungen

• Azure-Abonnement mit Berechtigungen zur Ressourcenerstellung
• Azure CLI installiert von https://aka.ms/installazurecliwindows
• PowerShell 7 oder höher
• Zugriff auf das EasyLife Cockpit

Infrastruktur-Deployment

Mit PowerShell und Azure CLI

Zuerst nutzen wir PowerShell und Azure CLI, um uns bei unserem Azure-Abonnement anzumelden, eine Ressourcengruppe und eine Function App zu erstellen und Umgebungsvariablen hinzuzufügen:

  # Diese Variablen aktualisieren
  $resourceGroup = "rg-easylife-webhook"
  $location = "westeurope"
  $storageAccount = "saeasylifewebhook"
  $functionApp = "func-easylife-webhook"
  $mailFromAddress = "noreply@easylife365.cloud"
  $mailToAddresses = "user1@easylife365.cloud user2@easylife365.cloud"

  # Bei Azure anmelden
  az login

  # Ressourcengruppe erstellen
  az group create --name $resourceGroup --location $location

  # Storage Account erstellen
  az storage account create `
      --name $storageAccount `
      --location $location `
      --resource-group $resourceGroup `
      --sku Standard_LRS

  # Function App erstellen
  $funcAppOutput = az functionapp create `
      --name $functionApp `
      --storage-account $storageAccount `
      --consumption-plan-location $location `
      --resource-group $resourceGroup `
      --runtime powershell `
      --functions-version 4 `
      --assign-identity '[system]' | ConvertFrom-Json

  # Umgebungsvariablen der Function App hinzufügen
  az functionapp config appsettings set `
      --name $functionApp `
      --resource-group $resourceGroup `
      --settings mailFromAddress=$mailFromAddress mailToAddresses=$mailToAddresses

Hinweis: Der Code ist auf unserem GitHub verfügbar, wo du auch Bicep-Templates findest.

Berechtigungen zuweisen

Die Azure Function verwendet ihre systemzugewiesene verwaltete Identität zur Authentifizierung bei Microsoft Graph. Nach dem Deployment der Function App musst du folgende Graph API-Berechtigungen der verwalteten Identität erteilen:

• User Read All
• Group Read All
• Mail Send

  # Service-Principals für die Berechtigungszuweisung abrufen
  $servicePrincipalId = $funcAppOutput.identity.principalId
  $graphObjectId = (az ad sp list --display-name 'Microsoft Graph' | ConvertFrom-Json)[0].id

  # Berechtigungen der verwalteten Identität zuweisen
  @(
      'df021288-bdef-4463-88db-98f22de89214', # user.read.all
      '5b567255-7703-4780-807c-7be8301ae99b', # group.read.all
      'b633e1c5-b582-4048-a93e-9f11b44c7e96'  # mail.send
  ) | ForEach-Object {
      $body = @{
          principalId = $servicePrincipalId
          resourceId = $graphObjectId
          appRoleId = $_
      } | ConvertTo-Json -Compress
      $uri = "https://graph.microsoft.com/v1.0/servicePrincipals/$servicePrincipalId/appRoleAssignments"
      $header = "Content-Type=application/json"
      az rest --method POST --uri $uri --header $header --body $body.Replace('"',"'")
  }

Den PowerShell-Code deployen

Nach der Infrastruktureinrichtung wird der Funktionscode deployed. Das Repository enthält zwei Hauptfunktionen:

• mailrequest/run.ps1: Die HTTP-getriggerte Funktion, die Webhooks empfängt
• mailqueue/run.ps1: Die Queue-getriggerte Funktion, die E-Mails sendet

  # Deployment-Paket aktualisieren
  $deployPath = Get-ChildItem | `
      Where-Object { $_.Name -notmatch "deploypkg" -and $_.Name -notmatch "_automation" } | ` `
      Compress-Archive -DestinationPath deploypkg.zip -Force -PassThru

  # Das gezippte Paket deployen
  az functionapp deployment source config-zip `
      --name $functionAppName `
      --resource-group $resourceGroupName `
      --src $deployPath.FullName

Die Funktion testen

1. Funktions-URL abrufen:

• Function App im Azure Portal öffnen
• Zu Functions > mailrequest navigieren
• Auf "Funktions-URL abrufen" klicken
• Die vollständige URL mit Code-Parameter kopieren

2. Mit PowerShell testen:

  # Function App HTTP-Endpunkt aufrufen
  $uri = 'https://<functionAppName>.azurewebsites.net/api/mailrequest?code=<code>'
  $body = @{
      eventType = "groupcreated"
      user = @{
          userPrincipalName = "testbenutzer@deinedomain.com"
      }
      group = @{
          displayName = "Test Team"
          id = "00000000-0000-0000-0000-000000000000"
      }
  } | ConvertTo-Json -Compress
  Invoke-RestMethod -Uri $uri -Body $body -Method Post

EasyLife konfigurieren

Nach erfolgreichem Test die Funktions-URL zur Webhook-Konfiguration im EasyLife Cockpit hinzufügen:

• Das EasyLife Cockpit öffnen
• Zu Templates > Teams navigieren
• Ein bestehendes Template auswählen oder ein neues erstellen
• Unter Bereitstellung die Funktions-URL in das Webhook-Feld einfügen
• Änderungen speichern

Bewährte Methoden

• Fehlerbehandlung: Umfassendes Error-Handling in den Funktionen implementieren.
• Monitoring: Application Insights zur Überwachung der Funktionsleistung nutzen.
• Sicherheit: Funktionsschlüssel regelmässig rotieren und sensible Daten sicher im Key Vault speichern.
• Testen: Eine dedizierte Entwicklungsumgebung für Tests nutzen.
• Protokollierung: Detaillierte Protokollierung für die Fehlerbehebung implementieren.

Weitere Ressourcen

• EasyLife-Dokumentation
• EasyLife PowerShell-Modul
• Beispiel-Code-Repository
• Azure Functions-Dokumentation

Fazit: Microsoft 365-Governance mit Webhook-Integration anpassen

Webhooks bieten eine leistungsstarke Möglichkeit, die Funktionalität von EasyLife 365 Collaboration zu erweitern und nahtlos in bestehende Systeme zu integrieren. Dieses Beispiel zeigt nur einen möglichen Anwendungsfall. Das gleiche Muster kann für viele andere Szenarien angepasst werden:

• Ticketsystem-Integration
• Benutzerdefinierte Benachrichtigungen für Richtlinien-Eskalationen
• Benutzerdefinierte SharePoint-Site-Bereitstellung
• Compliance-Berichterstattung
• Benutzerdefinierte Genehmigungsworkflows

Weitere Beiträge in dieser Serie kommen bald.

Für mehr Informationen und Support besuche unsere Dokumentation unter docs.easylife365.cloud oder kontaktiere uns für persönliche Beratung und Unterstützung.