Herstellen einer Verbindung mit einer Microsoft 365-Gruppe

Artikel
04/08/2023

Die Möglichkeit, eine Microsoft 365-Gruppe mit einer vorhandenen SharePoint-Website zu verbinden, ist wichtig, wenn Sie diese Website modernisieren möchten. Nach der Verbindung mit einer Microsoft 365-Gruppe kann Ihre Website von allen anderen „gruppifizierten“ Diensten wie Microsoft Teams und Planner usw. profitieren. Auf diese Weise wird Ihre „klassische“ Website der aktuellen modernen Teamwebsite, die standardmäßig mit einer Microsoft 365-Gruppe verbunden ist, einen Schritt nähergebracht.

Sie können Ihre Website über die Benutzeroberfläche Website für Website mit einer neuen Microsoft 365-Gruppe verbinden. Dies ist besonders für kleinere Umgebungen empfehlenswert. Größere Kunden möchten ihren Benutzern jedoch häufig eine konsistente Oberfläche bieten und möchten daher eine „Massengruppifzierung“ ihrer Websites durchführen.

In diesem Artikel erfahren Sie, wie Sie eine solche „Massengruppifizierung“ vorbereiten und umsetzen, um ihre Websites neuen Microsoft 365-Gruppen zuzuordnen.

Wichtig

Es wird nicht unterstützt, um eine Verbindung zwischen einer Kommunikationswebsite und einer Microsoft 365-Gruppe herzustellen.
Sie können keine Verbindung zwischen der Stammwebsitesammlung in Ihrem Mandanten und einer Gruppe herstellen.

Wichtig

Modernisierungstools und alle anderen PnP-Komponenten sind Open-Source-Werkzeuge, die von einer aktiven Community unterstützt werden. Es gibt keine SLA für die Unterstützung von Open Source-Tools durch offizielle Microsoft-Supportkanäle.

Wie wirkt sich das Verbinden mit einer neuen Microsoft 365-Gruppe auf Ihre Website aus?

Wenn Sie Ihre Website mit einer neuen Microsoft 365-Gruppe verbinden, passiert Folgendes:

Es wird eine neue Microsoft 365-Gruppe erstellt, die mit Ihrer Websitesammlung verbunden wird.
Auf Ihrer Website wird eine neue, moderne Startseite erstellt und als Startseite der Website festgelegt.
Die Gruppenbesitzer sind jetzt die Websitesammlungsadministratoren.
Die Gruppenbesitzer werden der Besitzergruppe Ihrer Website hinzugefügt.
Die Mitglieder der Gruppe werden der Gruppe „Mitglieder“ Ihrer Website hinzugefügt.

Nach der Verbindung mit einer Microsoft 365-Gruppe verhält sich die Website wie eine moderne mit einer Gruppe verbundene Teamwebsite. Wenn Sie Personen Berechtigungen für die verbundene Microsoft 365-Gruppe erteilen, erhalten diese nun auch Zugriff auf die SharePoint-Website, ein Microsoft-Team kann am Anfang der Website erstellt werden, Planner kann integriert werden usw.

Verbinden einer Microsoft 365-Gruppe mithilfe der SharePoint-Benutzeroberfläche

Ein Ansatz zum Verbinden einer Microsoft 365-Gruppe mit Ihrer Website besteht darin, die in der Benutzeroberfläche verfügbare Option zu verwenden. Wenn Sie auf das Zahnradsymbolin der Navigationsleiste klicken, können Sie die Option Mit neuer Microsoft 365-Gruppe verbinden auswählen. Über diese Option wird ein Assistent gestartet, der Sie durch den „Gruppifizierungsprozess“ führt, wie in den folgenden Screenshots dargestellt.

Websiteaktionen-Menü (Zahnradsymbol)

Websiteaktionen

Assistent

Assistent

Programmgesteuerte Verbindung einer Microsoft 365-Gruppe

Wenn Sie eine Microsoft 365-Gruppe programmgesteuert verbinden möchten, empfehlen wir, dass Sie diesem dreistufigen Prozess folgen:

Lernen
Analysieren
Modernisieren

Schritt 1: Erfahren Sie, was die „Gruppifizierung“ mit Ihrer Website macht

Es ist wichtig, dass Sie sich damit vertraut machen, welche Auswirkungen die „Gruppifizierung“ auf Ihre Website hat. Deshalb wird empfohlen, dass Sie für einige Testwebsites eine manuelle „Gruppifizierung“ mithilfe der Benutzeroberflächenoption ausführen. Ein wichtiger Aspekt, der berücksichtigt werden muss, ist, ob Sie die neu erstellte moderne Startseite beibehalten möchten oder nicht. Im Rahmen des Modernisierungsskripts können Sie zwar eine maßgeschneiderte Startseite erstellen, aber wenn die standardmäßig erstellte Ihren Anforderungen entspricht, ist dies die bevorzugte Option.

Schritt 2: Analysieren Sie Ihre Websites

Die im vorherigen Kapitel dargestellte Benutzeroberflächenoption ist nicht geeignet, wenn Sie Hunderte von Websitesammlungen „gruppifizieren“ möchten. Hierfür ist die Verwendung einer API zum programmgesteuerten Ausführen dieses Vorgangs sinnvoll. Vorher sollten Sie jedoch überprüfen, welche Websites bereit für die „Gruppifizierung“ sind, da nicht alle Websites dafür geeignet sind.

Um zu verstehen, welche Websites bereit für die „Gruppifizierung“ sind, können Sie den SharePoint-Modernisierungscanner verwenden, um Ihre Umgebung zu analysieren. Dieser Link enthält alle erforderlichen Details zum Ausführen des Scanners. Nachdem Sie den Scanner ausgeführt haben, wechseln Sie zu dem Artikel Verstehen und Verarbeiten der Scannerergebnisse, um die Scanergebnisse zu analysieren.

Schritt 3: Modernisieren

Der tatsächliche „Massengruppifizierungsprozess“ besteht aus zwei Schritten:

Vorbereiten und Überprüfen einer Eingabedatei, die für den „Massengruppifizierungsprozess“ verwendet wird.
Ausführen des „Massengruppifizierungsprozesses“.

Erstellen Sie eine Eingabedatei für die „Massengruppifizierung“, und überprüfen Sie sie.

Nach dem Ausführen des Scanners und der Verarbeitung der Ergebnisse haben Sie die Websites identifiziert, die für die „Gruppifizierung“ geeignet sind. Der nächste Schritt besteht darin, eine CSV-Datei für den „Massengruppifizierungsprozess“ vorzubereiten. Das Format der CSV-Datei ist ganz einfach:

Die Spalte URL enthält die URL der Websitesammlung, die „gruppifiziert“ werden soll.
Alias enthält den Alias der Microsoft 365-Gruppe, die Sie verwenden möchten. Beachten Sie, dass dieser Alias keine Leerzeichen enthalten und zuvor noch nicht verwendet worden sein darf.
IsPublic gibt an, ob die Website öffentlich oder privat sein soll.
Classification enthält die Websiteklassifizierung, die Sie nach der „Gruppifizierung“ für die Website festlegen möchten. Dies ist erforderlich, da diese Klassifizierung nach dem Verbinden mit einer Gruppe auf Microsoft 365-Gruppenebene gespeichert wird.

Hier folgt ein kurzes Beispiel:

Url,Alias,IsPublic,Classification
https://contoso.sharepoint.com/sites/hrteam,hrteam,false,Medium Impact
https://contoso.sharepoint.com/sites/engineering,engineeringteam,true,Low Impact

Damit Sie diese Datei vor der Verwendung überprüfen können, können Sie das folgende PowerShell-Skript verwenden. Dieses Skript prüft auf gültige Website-URLs und Aliase. Aktualisieren Sie dieses Skript mit der Admin Center-URL für Ihren Mandanten, und führen Sie es aus. Das Skript fragt nach dem Namen der CSV-Datei und erstellt einen Bericht für Sie.

Während der Ausführung des Validierungsskripts können die folgenden Fehler angezeigt werden:

Fehler	Beschreibung
*Azure AD-Benennungsrichtlinie: PrefixSuffix* enthält keine Active Directory-Attribute, die basierend auf dem Benutzer, der die „Gruppifizierung“ ausführt, aufgelöst werden können**	In Azure AD können Sie eine Benennungsrichtlinie für Microsoft 365-Gruppendefinieren. Wenn diese Richtlinie Active Directory-Attribute für Benutzer enthält, kann dies ein Problem sein, da die „Massengruppifizierung“ alle Websites mithilfe des aktuellen Benutzers verarbeitet.
*Erstellungsrichtlinie ausführen: adminUPN* ist kein Mitglied der Gruppe CanCreateGroupsId, die die Erstellung von Microsoft 365-Gruppen steuert**	Wenn die Erstellung von Azure Active Directory-Gruppen auf bestimmte Konten beschränkt ist und sich das aktuelle Konto nicht darunter befindet, so schlägt die Erstellung der Microsoft 365-Gruppe fehl.
siteUrl: Alias [siteAlias] enthält ein Leerzeichen, das nicht zulässig ist	Der Alias der Microsoft 365-Gruppe darf kein Leerzeichen enthalten.
siteUrl: Klassifizierung [siteClassification] entspricht nicht den verfügbaren Azure AD-Klassifizierungen [ClassificationListString]	Die bereitgestellte Websiteklassifizierung ist nicht als eine der zulässigen Websiteklassifizierungen für Microsoft 365-Gruppen definiert.
SiteUrl: Alias [siteAlias] befindet sich in der Liste blockierter Wörter in Azure AD [CustomBlockedWordsListString]	Wenn eine Liste blockierter Wörter in Azure AD eingerichtet ist und der bereitgestellte Name der Microsoft 365-Gruppe ein solches Wort verwendet, wird dieser Fehler generiert.
siteUrl: Die Website ist bereits mit einer Gruppe verbunden	Eine Website kann nur mit einer einzelnen Microsoft 365-Gruppe verbunden sein, sobald die Website also verbunden ist, kann sie nicht mehr „gruppifiziert“ werden.
siteUrl : Der Alias [siteAlias] wird bereits verwendet	Jede Microsoft 365-Gruppe benötigt einen eindeutigen Alias, daher wird ein Fehler generiert, wenn der vorgeschlagene Alias bereits von einer anderen Microsoft 365-Gruppe verwendet wurde.
siteUrl: Der Alias [siteAlias] wurde bereits als genehmigter Alias für eine andere Website in dieser Datei gekennzeichnet	Der vorgeschlagene Websitealias wurde bereits für eine andere Website in früheren Eingabezeilen der CSV-Datei für die „Massengruppifizierung“ definiert.
siteUrl : Website ist nicht vorhanden oder nicht verfügbar (Status = site.Status)	Die angegebene Website-URL stellt keine erreichbare Websitesammlung dar.

Hinweis

Aktualisieren Sie die $tenantAdminUrl-Variable im folgenden Skript so, dass sie Ihre Mandanten-Admin Center-URL enthält (z. B. https://contoso-admin.sharepoint.com).

Während das Skript ausgeführt wird, wird eine Protokolldatei zusammen mit einer Fehlerdatei generiert, die eine Untergruppe der Protokolldatei enthält (nur die Fehler).

<#
.SYNOPSIS
Validates the CSV input file for the bulk "Office 365 Group Connects". 

.EXAMPLE
PS C:\> .\ValidateInput.ps1
#>

#region Logging and generic functions
function LogWrite
{
    param([string] $log , [string] $ForegroundColor)

    $global:strmWrtLog.writeLine($log)
    if([string]::IsNullOrEmpty($ForegroundColor))
    {
        Write-Host $log
    }
    else
    {    
        Write-Host $log -ForegroundColor $ForegroundColor
    }
}

function LogError
{
    param([string] $log)
    
    $global:strmWrtError.writeLine($log)
}

function IsGuid
{
    param([string] $owner)

    try
    {
        [GUID]$g = $owner
        $t = $g.GetType()
        return ($t.Name -eq "Guid")
    }
    catch
    {
        return $false
    }
}

function IsGroupConnected
{
    param([string] $owner)

    if (-not [string]::IsNullOrEmpty($owner))
    {
        if ($owner.Length -eq 38)
        {
            
            if ((IsGuid $owner.Substring(0, 36)) -and ($owner.Substring(36, 2) -eq "_o"))
            {
                return $true
            }
        }        
    }

    return $false
}

function ContainsADAttribute
{
    param($PrefixSuffix)

    $ADAttributes = @("[Department]", "[Company]", "[Office]", "[StateOrProvince]", "[CountryOrRegion]", "[Title]")


    foreach($attribute in $ADAttributes)
    {
        if ($PrefixSuffix -like "*$attribute*")
        {
            return $true
        }
    }

    return $false
}

#endregion

#######################################################
# MAIN section                                        #
#######################################################
# Tenant admin url
$tenantAdminUrl = "https://contoso-admin.sharepoint.com"
# If you use credential manager then specify the used credential manager entry, if left blank you'll be asked for a user/pwd
$credentialManagerCredentialToUse = ""

#region Setup Logging
$date = Get-Date
$logfile = ((Get-Item -Path ".\" -Verbose).FullName + "\GroupconnectInputValidation_log_" + $date.ToFileTime() + ".txt")
$global:strmWrtLog=[System.IO.StreamWriter]$logfile
$global:Errorfile = ((Get-Item -Path ".\" -Verbose).FullName + "\GroupconnectInputValidation_error_" + $date.ToFileTime() + ".txt")
$global:strmWrtError=[System.IO.StreamWriter]$Errorfile
#endregion

#region Load needed PowerShell modules
#Ensure PnP PowerShell is loaded
$minimumVersion = New-Object System.Version("2.24.1803.0")
if (-not (Get-InstalledModule -Name SharePointPnPPowerShellOnline -MinimumVersion $minimumVersion -ErrorAction Ignore)) 
{
    Install-Module SharePointPnPPowerShellOnline -MinimumVersion $minimumVersion -Scope CurrentUser -Force
}
Import-Module SharePointPnPPowerShellOnline -DisableNameChecking -MinimumVersion $minimumVersion
#endregion

#region Ensure Azure PowerShell is loaded
$minimumAzurePowerShellVersion = New-Object System.Version("2.0.0.137")
if (-not (Get-InstalledModule -Name AzureADPreview -MinimumVersion $minimumAzurePowerShellVersion -ErrorAction Ignore))
{
    install-module AzureADPreview -MinimumVersion $minimumAzurePowerShellVersion -Scope CurrentUser -Force
}

Import-Module AzureADPreview -MinimumVersion $minimumAzurePowerShellVersion

$siteURLFile = Read-Host -Prompt 'Input name of .CSV file to validate (e.g. sitecollections.csv) ?'

# Get the tenant admin credentials.
$credentials = $null
$adminUPN = $null
if(![String]::IsNullOrEmpty($credentialManagerCredentialToUse) -and (Get-PnPStoredCredential -Name $credentialManagerCredentialToUse) -ne $null)
{
    $adminUPN = (Get-PnPStoredCredential -Name $credentialManagerCredentialToUse).UserName
    $credentials = $credentialManagerCredentialToUse
    $azureADCredentials = Get-PnPStoredCredential -Name $credentialManagerCredentialToUse -Type PSCredential
}
else
{
    # Prompts for credentials, if not found in the Windows Credential Manager.
    $adminUPN = Read-Host -Prompt "Please enter admin UPN"
    $pass = Read-host -AsSecureString "Please enter admin password"
    $credentials = new-object management.automation.pscredential $adminUPN,$pass
    $azureADCredentials = $credentials
}

if($credentials -eq $null) 
{
    Write-Host "Error: No credentials supplied." -ForegroundColor Red
    exit 1
}
#endregion

#region Connect to SharePoint and Azure
# Get a tenant admin connection, will be reused in the remainder of the script
LogWrite "Connect to tenant admin site $tenantAdminUrl"
$tenantContext = Connect-PnPOnline -Url $tenantAdminUrl -Credentials $credentials -Verbose -ReturnConnection

LogWrite "Connect to Azure AD"
$azureUser = Connect-AzureAD -Credential $azureADCredentials
#endregion

#region Read Azure AD group settings
$groupSettings = (Get-AzureADDirectorySetting | Where-Object -Property DisplayName -Value "Group.Unified" -EQ)

$CheckGroupCreation = $false
$CanCreateGroupsId = $null
$CheckClassificationList = $false
$ClassificationList = $null
$CheckPrefixSuffix = $false
$PrefixSuffix = $null
$CheckDefaultClassification = $false
$DefaultClassification = $null
$CheckCustomBlockedWordsList = $false

if (-not ($groupSettings -eq $null))
{
    if (-not($groupSettings["EnableGroupCreation"] -eq $true))
    {
        # Group creation is restricted to a security group...verify if the current user is part of that group
        # See: https://support.office.com/en-us/article/manage-who-can-create-office-365-groups-4c46c8cb-17d0-44b5-9776-005fced8e618?ui=en-US&rs=en-001&ad=US
        $CheckGroupCreation = $true
        $CanCreateGroupsId = $groupSettings["GroupCreationAllowedGroupId"]
    }

    if (-not ($groupSettings["CustomBlockedWordsList"] -eq ""))
    {
        # Check for blocked words in group name
        # See: https://support.office.com/en-us/article/office-365-groups-naming-policy-6ceca4d3-cad1-4532-9f0f-d469dfbbb552?ui=en-US&rs=en-001&ad=US
        $CheckCustomBlockedWordsList = $true
        $option = [System.StringSplitOptions]::RemoveEmptyEntries
        $CustomBlockedWordsListString = $groupSettings["CustomBlockedWordsList"]
        $CustomBlockedWordsList = $groupSettings["CustomBlockedWordsList"].Split(",", $option)
        
        # Trim array elements
        [int] $arraycounter = 0
        foreach($c in $CustomBlockedWordsList)
        {
            $CustomBlockedWordsList[$arraycounter] = $c.Trim(" ")
            $arraycounter++
        }
    }

    if (-not ($groupSettings["PrefixSuffixNamingRequirement"] -eq ""))
    {
        # Check for prefix/suffix naming - any dynamic tokens beside [groupname] can be problematic since all 
        # groups are created using the user running the bulk group connect
        # See: https://support.office.com/en-us/article/office-365-groups-naming-policy-6ceca4d3-cad1-4532-9f0f-d469dfbbb552?ui=en-US&rs=en-001&ad=US
        $CheckPrefixSuffix = $true
        $PrefixSuffix = $groupSettings["PrefixSuffixNamingRequirement"]
    }

    if (-not ($groupSettings["ClassificationList"] -eq ""))
    {
        # Check for valid classification labels
        # See: https://support.office.com/en-us/article/Manage-Office-365-Groups-with-PowerShell-aeb669aa-1770-4537-9de2-a82ac11b0540 
        $CheckClassificationList = $true

        $option = [System.StringSplitOptions]::RemoveEmptyEntries
        $ClassificationListString = $groupSettings["ClassificationList"]
        $ClassificationList = $groupSettings["ClassificationList"].Split(",", $option)
        
        # Trim array elements
        [int] $arraycounter = 0
        foreach($c in $ClassificationList)
        {
            $ClassificationList[$arraycounter] = $c.Trim(" ")
            $arraycounter++
        }

        if (-not ($groupSettings["DefaultClassification"] -eq ""))
        {        
            $CheckDefaultClassification = $true
            $DefaultClassification = $groupSettings["DefaultClassification"].Trim(" ")
        }
    }    
}
#endregion

#region Validate input
LogWrite "General Azure AD validation"
if ($CheckPrefixSuffix -and (ContainsADAttribute $PrefixSuffix))
{
    $message = "[ERROR] AzureAD Naming policy : $PrefixSuffix does contain AD attributes that are resolved based on the user running the group connect"
    LogWrite $message Red
    LogError $message                         
}

if ($CheckGroupCreation)
{
    $groupToCheck = new-object Microsoft.Open.AzureAD.Model.GroupIdsForMembershipCheck
    $groupToCheck.GroupIds = $CanCreateGroupsId
    $accountToCheck = Get-AzureADUser -SearchString $adminUPN
    $groupsUserIsMemberOf = Select-AzureADGroupIdsUserIsMemberOf -ObjectId $accountToCheck.ObjectId -GroupIdsForMembershipCheck $groupToCheck
    if ($groupsUserIsMemberOf -eq $null)
    {
        $message = "[ERROR] AzureAD Creation policy : $adminUPN is not part of group $CanCreateGroupsId which controls Office 365 Group creation"
        LogWrite $message Red
        LogError $message                         
    }
}

# "approved" aliases
$approvedAliases = @{}

LogWrite "Validating rows in $siteURLFile..."
$csvRows = Import-Csv $siteURLFile

foreach($row in $csvRows)
{
    if($row.Url.Trim() -ne "")
    {
        $siteUrl = $row.Url
        $siteAlias = $row.Alias
        $siteClassification = $row.Classification
        if ($siteClassification -ne $null)
        {
            $siteClassification = $siteClassification.Trim(" ")
        }

        LogWrite "[VALIDATING] $siteUrl with alias [$siteAlias] and classification [$siteClassification]"

        try 
        {
            # First perform validations that do not require to load the site
            if ($siteAlias.IndexOf(" ") -gt 0)
            {
                $message = "[ERROR] $siteUrl : Alias [$siteAlias] contains a space, which not allowed"
                LogWrite $message Red
                LogError $message 
            }
            elseif (($CheckClassificationList -eq $true) -and (-not ($ClassificationList -contains $siteClassification)))
            {
                $message = "[ERROR] $siteUrl : Classification [$siteClassification] does not comply with available AzureAD classifications [$ClassificationListString]"
                LogWrite $message Red
                LogError $message                         
            }     
            elseif (($CheckCustomBlockedWordsList -eq $true) -and ($CustomBlockedWordsList -contains $siteAlias))
            {
                $message = "[ERROR] $siteUrl : Alias [$siteAlias] is in the AzureAD blocked word list [$CustomBlockedWordsListString]"
                LogWrite $message Red
                LogError $message                         
            }                       
            else 
            {
                # try getting the site
                $site = Get-PnPTenantSite -Url $siteUrl -Connection $tenantContext -ErrorAction Ignore
                
                if ($site.Status -eq "Active")
                {
                    if (IsGroupConnected $site.Owner)
                    {
                        $message = "[ERROR] $siteUrl : Site is already connected a group"
                        LogWrite $message Red
                        LogError $message 
                    }
                    else
                    {
                        $aliasIsUsed = Test-PnPOffice365GroupAliasIsUsed -Alias $siteAlias -Connection $tenantContext      
                        if ($aliasIsUsed)
                        {
                            $message = "[ERROR] $siteUrl : Alias [$siteAlias] is already in use"
                            LogWrite $message Red
                            LogError $message   
                        }
                        elseif ($approvedAliases.ContainsKey($siteAlias))
                        {
                            $message = "[ERROR] $siteUrl : Alias [$siteAlias] was already marked as approved alias for another site in this file"
                            LogWrite $message Red
                            LogError $message   
                        }
                        else 
                        {
                            $approvedAliases.Add($siteAlias, $siteAlias)
                            LogWrite "[VALIDATED] $siteUrl with alias [$siteAlias] and classification [$siteClassification]" Green
                        }                        
                    }
                }
                else 
                {
                    $message = "[ERROR] $siteUrl : Site does not exist or is not available (status = $($site.Status))"
                    LogWrite $message Red    
                    LogError $message
                }                
            }
        }
        catch [Exception]
        {
            $ErrorMessage = $_.Exception.Message
            LogWrite "Error: $ErrorMessage" Red
            LogError $ErrorMessage    
        }
        
    }
}
#endregion

#region Close log files
if ($global:strmWrtLog -ne $NULL)
{
    $global:strmWrtLog.Close()
    $global:strmWrtLog.Dispose()
}

if ($global:strmWrtError -ne $NULL)
{
    $global:strmWrtError.Close()
    $global:strmWrtError.Dispose()
}
#endregion

Ausführen der „Massengruppifizierung“

Da wir nun eine Eingabedatei haben, die die Websites definiert, die „gruppifiziert“ werden müssen, können wir den Vorgang endlich ausführen. Das folgende PowerShell-Skript ist ein Beispielskript, das Sie an Ihre Anforderungen anpassen können, je nachdem wie viele Elemente Teil der „Gruppifizierung“ sein sollen.

Die freigegebene Beispielversion des Skripts implementiert die folgenden Schritte:

Hinzufügen des aktuellen Mandantenadministrators als Websiteadministrator (falls erforderlich): Für die „Gruppifizierung“ ist ein Benutzerkonto erforderlich (nicht Nur-App).
Überprüfen der Verwendung der Websitevorlage/des Veröffentlichungsfeatures und Verhindern der „Gruppifizierung“, ausgerichtet an der Logik im Scanner.
Sicherstellen, dass keine Blockierungsfeatures für moderne Benutzeroberflächen aktiviert sind (Korrigieren, falls vorhanden).
Sicherstellen, dass das Feature für moderne Seiten aktiviert ist.
Optional: Bereitstellen von Anwendungen (z. B. Application Customizer)
Optional: Hinzufügen Ihrer eigenen modernen Startseite.
Aufrufen der „Gruppifizierungs-API“.
Definieren von Websiteadministratoren und Websitebesitzern als Gruppenbesitzer.
Definieren von Websitemitgliedern als Gruppenmitglieder.
Entfernen von hinzugefügten Mandantenadministratoren und Websitebesitzern aus SharePoint-Administratoren.
Entfernen von hinzugefügten Mandantenadministratoren aus der Microsoft 365-Gruppe.

Zum Ausführen des folgenden PowerShell-Skripts müssen Sie die Mandanten-Admin Center-URL aktualisieren und zur Laufzeit Anmeldeinformationen sowie die CSV-Eingabedatei angeben.