So automatisiert ihr die Speicherkapazität in SharePoint für Hunderte von Teams

Die Verwaltung der Speicherkapazität in SharePoint kann für Unternehmen, die regelmäßig neue Teams erstellen, eine Herausforderung darstellen. Der verfügbare Speicherplatz hängt von den jeweils erworbenen Microsoft 365-Lizenzen ab und kann stark variieren. Für Organisationen mit Hunderten von neuen Teams pro Woche ist die manuelle Anpassung der Speichergröße jedoch nicht praktikabel. Daher möchten wir in diesem Beitrag zeigen, wie ihr den Prozess automatisieren könnt – von der Einrichtung über PowerShell bis hin zu einem Worker-Script in Node.js.

Warum eine Automatisierung sinnvoll ist

Die klassische Methode, die Speicherkapazität über das SharePoint-Admincenter zu verwalten, funktioniert zwar gut, ist jedoch für Unternehmen mit hohem Volumen zu zeitaufwändig. Eine Automatisierung bietet folgende Vorteile:

1. Zeitersparnis: Manuelle Schritte entfallen.
2. Skalierbarkeit: Hunderte Teams können effizient verarbeitet werden.
3. Fehlerreduktion: Automatisierte Prozesse minimieren menschliche Fehler.

Da die Microsoft Graph API aktuell keine direkte Unterstützung für die Anpassung von SharePoint-Speicherkontingenten bietet, setzen wir auf ein PowerShell-Script, das mit modernen Authentifizierungsoptionen ausgestattet ist.

Voraussetzungen für die Automatisierung

1. PowerShell 7

PowerShell 7 ist erforderlich, um die benötigten Module zu nutzen. Die Installation auf Ubuntu kann hier nachvollzogen werden.

2. PnP.PowerShell

Im Gegensatz zu Microsoft.Online.SharePoint.PowerShell bietet PnP.PowerShell nicht nur moderne Authentifizierungsoptionen, sondern ermöglicht es uns auch, den gesamten Authentifizierungsprozess zu automatisieren. Das ist besonders wichtig, da wir bei einer automatisierten Lösung nicht manuell eingreifen können, um z. B. Zugangsdaten einzugeben.

3. Azure AD App und Zertifikat

Um das PowerShell-Script auszuführen, benötigt ihr eine Azure AD App mit folgenden Berechtigungen:

• Sites.FullControl.All (Anwendungsberechtigungen in SharePoint)

Ein selbstsigniertes Zertifikat reicht für Tests aus. Für produktive Szenarien empfiehlt sich ein Zertifikat von einer anerkannten Zertifizierungsstelle. Eine kurze Anleitung zur Erstellung eines Zertifikats findet ihr im nächsten Abschnitt.

Erstellung eines Zertifikats

Damit ihr eure Azure AD App nutzen könnt, benötigt ihr ein X.509-Zertifikat. Dieses kann entweder selbstsigniert oder von einer Zertifizierungsstelle ausgestellt sein. Hier ein Beispiel zur Erstellung eines selbstsignierten Zertifikats unter Windows:

# Erstellen eines selbstsignierten Zertifikats
$cert = New-SelfSignedCertificate -Subject "CN=MeineAzureADApp" -KeySpec Signature -KeyLength 2048 -KeyExportPolicy Exportable -HashAlgorithm SHA256 -CertStoreLocation "Cert:\CurrentUser\My"

# Export des Zertifikats
Export-PfxCertificate -Cert $cert -FilePath "C:\Pfad\Zu\meinerAzureADApp.pfx" -Password (ConvertTo-SecureString -String "MeinPasswort" -Force -AsPlainText)
Export-Certificate -Cert $cert -FilePath "C:\Pfad\Zu\meinerAzureADApp.cer"


Für die Konfiguration der Azure AD App mit dem Zertifikat folgt dieser Anleitung.

Schritt 1: PowerShell-Script für die Speicheranpassung

Das PowerShell-Script dient dazu, das Speicherkontingent und das Warnungslimit für eine spezifische SharePoint-Seite automatisch anzupassen. Es verwendet PnP.PowerShell, um sich mit der SharePoint-Admin-API zu verbinden, und führt die Änderungen basierend auf übergebenen Parametern wie Seitenname, maximalem Speicher und Warnungslimit durch. Dank moderner Authentifizierungsoptionen über ein Zertifikat kann der Prozess vollständig automatisiert ablaufen.

Param(
   [Parameter(Mandatory=$true)]
   [string]$SiteName,

   [Parameter(Mandatory=$true)]
   [int]$NewStorageGB,

   [Parameter(Mandatory=$true)]
   [int]$NewStorageWarningGB
)

Import-Module PnP.PowerShell
 
# Parameter
$Tenant = "XXXX"
$AdminCenterURL = "https://$Tenant-admin.sharepoint.com"
$SiteURL = "https://$Tenant.sharepoint.com/sites/$SiteName"
$ClientId = "XXXXXXX"
$TenantId = "XXXXXXX"
$CertificatePath = "./meinerAzureADApp.pfx"
$CertificatePassword = ConvertTo-SecureString -String "XXXXXXXX" -Force -AsPlainText
 
# Verbindung herstellen  
Connect-PnPOnline -Url $AdminCenterURL -ClientId $ClientId -Tenant $TenantId -CertificatePath $CertificatePath -CertificatePassword $CertificatePassword

# Konvertiere GB zu MB
$NewStorageMB = $NewStorageGB * 1024
$NewStorageWarningMB = $NewStorageWarningGB * 1024

# Speicherkontingent in SharePoint Online erhöhen
Set-PnPSite -Identity $SiteURL -StorageMaximumLevel $NewStorageMB -StorageWarningLevel $NewStorageWarningMB
Disconnect-PnPOnline
Write-Host "Das Speicherkontingent für '$SiteName' wurde auf '$NewStorageMB' festgelegt." -ForegroundColor Green

Schritt 2: Node.js Worker mit zeitgesteuerter Ausführung

Ein Worker in Node.js holt sich alle Teams aus der Graph API und prüft, ob das Speicherkontingent für die zugehörigen SharePoint-Seiten bereits gesetzt wurde. Der Workflow sieht wie folgt aus:

1. Graph API-Aufruf: Hole alle Teams.
2. Datenbankprüfung: Prüfe, ob für ein Team das Speicherkontingent gesetzt wurde.
3. PowerShell-Script-Aufruf: Falls nötig, führe das PowerShell-Script aus.

Beispielimplementierung des Workers

Der Node.js-Worker ermittelt, für welche Teams die Speicherkontingente noch nicht angepasst wurden, und führt die notwendigen Schritte aus. Dafür holt er über die Microsoft Graph API den Namen der zugehörigen SharePoint-Seite basierend auf der Team-ID. Anschließend wird das PowerShell-Script aufgerufen, um die Anpassungen vorzunehmen. Dieser Workflow ermöglicht eine nahtlose Integration mit bestehenden Datenbanken und eine effiziente Verwaltung großer Teamvolumen.

const { exec } = require("child_process");

const fetch = require("node-fetch");

// Mock-Datenbank

const database = {

 getTeamsWithoutStorageQuota: async () => {

   // Beispiel: Rückgabe von Team-Namen und IDs

   return [{ teamName: "TeamA", teamId: "12345" }];

 },

};

// Funktion: SharePoint-Seiten-Namen über Graph API abrufen

const getSiteNameByTeamId = async (teamId) => {

 const token = "YOUR_ACCESS_TOKEN"; // Zugriffstoken für die Graph API

 const response = await fetch(`https://graph.microsoft.com/v1.0/groups/${teamId}/sites/root`, {

   headers: { Authorization: `Bearer ${token}` },

 });

 if (!response.ok) {

   throw new Error(`Fehler beim Abrufen des Site-Namens für Team-ID ${teamId}: ${response.statusText}`);

 }

 const data = await response.json();

 return data.name; // Der Name der SharePoint-Seite

};

// Funktion: PowerShell-Script ausführen

const setStorageQuota = (siteName, storageGB, warningGB) => {

 const command = `pwsh ./setStorageQuota.ps1 -SiteName "${siteName}" -NewStorageGB ${storageGB} -NewStorageWarningGB ${warningGB}`;

 exec(command, (error, stdout, stderr) => {

   if (error) {

     console.error(`Fehler: ${error.message}`);

     return;

   }

   if (stderr) {

     console.error(`stderr: ${stderr}`);

     return;

   }

   console.log(`stdout: ${stdout}`);

 });

};

// Worker ausführen

(async () => {

 try {

   const teams = await database.getTeamsWithoutStorageQuota();

   for (const team of teams) {

     console.log(`Bearbeite Team: ${team.teamName}`);

     const siteName = await getSiteNameByTeamId(team.teamId);

     console.log(`Ermittelter Site-Name für Team ${team.teamName}: ${siteName}`);

     setStorageQuota(siteName, 100, 90); // Beispielwerte für Speicher und Warnung

   }

 } catch (error) {

   console.error(`Fehler im Worker: ${error.message}`);

 }

})();

Zeitsteuerung mit Crontab

Der Node.js-Worker kann z. B. über Crontab täglich ausgeführt werden. Die Konfiguration kann je nach Betriebssystem variieren. Ein Beispiel für Linux:

1. Öffnet die Crontab mit dem Befehl:
2. crontab -e

3. Fügt den folgenden Eintrag hinzu, um das Script täglich um Mitternacht auszuführen:
4. 0 0 * * * cd /pfad/zum/projekt && npm run start-worker >> /pfad/zum/logfile.log 2>&1


Konzeptübertragung auf andere Programmiersprachen

Die gezeigte Implementierung in Node.js dient lediglich als Beispiel. Das Grundkonzept kann problemlos mit jeder anderen Programmiersprache umgesetzt werden, die das Ausführen von Befehlen auf der Kommandozeile unterstützt. Es handelt sich hierbei um vereinfachte Beispiele – die tatsächlichen Implementierungsdetails können je nach verwendeter API-Version, SDKs oder spezifischen Anforderungen variieren.

Fazit

Die hier vorgestellte Lösung zeigt, wie Unternehmen mit hohem Teamvolumen die Anpassung von SharePoint-Speicherkontingenten effizient automatisieren können. Durch die Kombination von PowerShell und einer Programmiersprache wie Node.js wird ein Prozess geschaffen, der sowohl flexibel als auch zuverlässig ist. In einem Praxisprojekt hat sich dieser Ansatz als besonders effektiv erwiesen und konnte die Verwaltung deutlich vereinfachen. Dank der Möglichkeit zur vollständigen Automatisierung werden manuelle Eingriffe minimiert, was Zeit spart und Fehler reduziert.

‍