Conectar con un grupo de Microsoft 365

Artículo
04/08/2023

La posibilidad de conectar un grupo de Microsoft 365 a un sitio existente de SharePoint es importante si quiere modernizar ese sitio. Una vez que el sitio esté conectado a un grupo de Microsoft 365, podrá beneficiarse de todos los demás servicios de grupos conectados, como Microsoft Teams y Planner. Gracias a esta conexión, el sitio clásico está a un paso más cerca de ser como el sitio de grupo moderno actual, que está conectado a un grupo de Microsoft 365 de forma predeterminada.

Puede conectar su sitio a un nuevo grupo de Microsoft 365 desde la interfaz de usuario sitio a sitio, lo que puede ser adecuado para entornos más pequeños. Sin embargo, los clientes más grandes suelen preferir una experiencia acorde con sus usuarios y, por tanto, realizan una operación masiva de sus sitios.

En este artículo, aprenderá a prepararse para una operación masiva a fin de asociar los sitios a los nuevos grupos de Microsoft 365 y lograr que esto suceda.

Importante

No se permite conectar un sitio de comunicación al grupo de Microsoft 365.
No se puede conectar en grupo la colección de sitios raíz de su espacio empresarial.

Importante

Las herramientas de modernización y todos los demás componentes PnP son herramientas de código abierto sostenidas por una comunidad activa que proporciona soporte técnico. Los canales oficiales de soporte técnico de Microsoft no ofrecen ningún contrato de nivel de servicio para herramientas de código abierto.

¿Qué le ocurre a un sitio cuando lo conecta a un nuevo grupo de Microsoft 365?

Cuando conecte un sitio a un nuevo grupo de Microsoft 365, ocurrirán varias cosas:

Se creará un nuevo grupo de Microsoft 365, que se conectará a la colección de sitios.
Se creará una nueva página principal moderna en el sitio y se establecerá como página principal del sitio.
Los propietarios del grupo ahora serán los administradores de la colección de sitios.
Se agregarán los propietarios del grupo al grupo de propietarios del sitio.
Se agregarán los miembros del grupo al grupo de miembros del sitio.

Una vez conectado a un grupo de Microsoft 365, el sitio se comportará como un sitio de grupo moderno conectado a un grupo, de forma que, al conceder permisos a las personas al grupo de Microsoft 365 conectado, ahora también se concederá acceso al sitio de SharePoint, se podrá crear un Microsoft Team basado en el sitio, se podrá integrar Planner, etc.

Conectar un grupo de Microsoft 365 mediante la interfaz de usuario de SharePoint

Un primer enfoque para conectar un grupo de Microsoft 365 a su sitio es usar la opción disponible en la interfaz de usuario. Si selecciona el icono de engranaje en la barra de navegación, podrá elegir la opción Conectarse a un nuevo grupo de Microsoft 365, que iniciará un asistente que le guiará por el proceso de conexión en grupo, tal y como se muestra en las siguientes capturas de pantalla.

Menú Acciones del sitio (icono de engranaje)

Acciones del sitio

Asistente

Asistente

Conectar mediante programación un grupo de Microsoft 365

Para conectar mediante programación un grupo de Microsoft 365, le recomendamos que siga un proceso de tres pasos:

Aprender
Analizar
Modernizar

Paso 1: Descubrir cómo impactan las conexiones en grupo en el sitio

Familiarizarse con lo qué le hará la conexión en grupo al sitio es importante y, por tanto, es recomendable realizar una conexión en grupo manual para algunos sitios de prueba mediante la opción de la interfaz de usuario. Un aspecto importante que se debe evaluar es si quiere conservar la página principal moderna recién creada. Como parte del script de modernización, podrá crear una página principal personalizada, pero si la predeterminada satisface sus necesidades, entonces esa es la opción preferida.

Paso 2: Analizar los sitios

La opción de interfaz de usuario que se muestra en la sección anterior no es adecuada si quiere conectar en grupos cientos de colecciones de sitios. En ese momento, usar una API para hacerlo mediante programación tiene mucho sentido. Pero, antes, es mejor comprobar qué sitios están listos para conectarse en grupo, ya que no todos son adecuados para este proceso.

Para ayudarlo a comprender qué sitios están listos para conectarse en grupo, use el Analizador de modernización de SharePoint para analizar su entorno. Este vínculo contiene todos los detalles necesarios para ejecutar el escáner. Tras ejecutar el escáner vaya al artículo Comprender y procesar los resultados del escáner para analizar los resultados del examen.

Paso 3: Modernizar los sitios

El proceso masivo de conexión en grupos consta de dos pasos:

Preparar y validar un archivo de entrada que usará para llevar a cabo el proceso de conexión en grupos masivos.
Ejecutar el proceso masivo de conexión en grupos

Crear un archivo de entrada para la conexión en grupos de forma masiva y validarlo

Después de ejecutar el analizador y procesar los resultados, ha identificado qué sitios están listos para conectar en grupo. El siguiente paso consiste en preparar un archivo CSV para llevar a cabo el proceso de conexión en grupo de forma masiva. El formato del archivo CSV es sencillo:

La columna URL contiene la URL a la colección de sitios que se conectaran en grupos.
Alias contiene el alias del grupo de Microsoft 365 que quiere usar. Tenga en cuenta que este alias no puede contener espacios y no se debe haber usado antes.
IsPublic indica si quiere que el sitio sea público o privado.
Classification contiene la clasificación del sitio que quiere establecer después de la conexión en grupo. Esto es necesario porque, después de conectarse a un grupo, esta clasificación se mantiene en el nivel de grupo de Microsoft 365.

A continuación, se incluye un ejemplo breve:

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

Para ayudar a comprobar el archivo antes de usarlo, puede usar el script de PowerShell que aparece al final de esta sección. Este script comprobará si las URL y los alias del sitio son válidos. Actualice este script con la dirección URL del centro de administración de su espacio empresarial y ejecútelo. El script le pedirá el nombre del archivo CSV y generará un informe.

Durante la ejecución del script de validación, pueden aparecer los siguientes errores:

Error	Descripción
*AzureAD Naming policy: PrefixSuffix* contiene atributos de AD que se resuelven en función del usuario que ejecuta la conexión en grupo**	En Azure AD, puede definir una directiva de nomenclatura para grupos de Microsoft 365. Si esta directiva contiene atributos de usuario de Active Directory, esto podría ser un problema, ya que la conexión en grupo de forma masiva controla todos los sitios con el usuario actual.
*AzureAD Creation policy: adminUPN* no forma parte del grupo CanCreateGroupsId que controla la creación de grupos de Microsoft 365**	Si la creación de grupos de Azure AD está restringida a cuentas determinadas y la cuenta actual no está entre esas, se producirá un error en la creación de grupos de Microsoft 365.
siteUrl: el alias [siteAlias] contiene espacios, lo que no está permitido	El alias de un grupo de Microsoft 365 no puede contener espacios.
siteUrl: la clasificación [siteClassification] no cumple con las clasificaciones de Azure AD disponibles [ClassificationListString]	La clasificación del sitio proporcionado no está definida como una de las clasificaciones permitidas para grupos de Microsoft 365.
siteUrl: el alias [siteAlias] está en la lista de términos bloqueados de Azure AD [CustomBlockedWordsListString]	Este error se genera cuando se configura una lista de términos bloqueados en Azure AD y el nombre del grupo de Microsoft 365 usa uno de esos términos.
siteUrl: el sitio ya está conectado a un grupo	Solo se puede conectar un sitio a un único grupo de Microsoft 365. Por ello, cuando se conecta un sitio, no se lo puede volver a conectar en grupo.
siteUrl: el alias [siteAlias] ya está en uso	Cada grupo de Microsoft 365 necesita un alias único, ya que se genera un error si el alias propuesto ya se ha usado en otro grupo de Microsoft 365.
siteUrl: ya se marcó el alias [siteAlias] como aprobado para otro sitio de este archivo	Ya se ha definido el alias del sitio propuesto para otro sitio en líneas de entrada anteriores del archivo CSV de conexión en grupo.
siteUrl: el sitio no existe o no está disponible (estado = site.Status)	La dirección URL proporcionada no representa una colección de sitios accesibles.

Nota:

Actualice la variable $tenantAdminUrl en el siguiente script para que contenga la dirección URL del centro de administración de su espacio empresarial (por ejemplo, https://contoso-admin.sharepoint.com).

Durante la ejecución del script, se generará un archivo de registro junto con un archivo de errores que contendrá un subconjunto del archivo de registro (solo los errores).

<#
.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

Ejecute el proceso masivo de conexión en grupos.

Ahora que tenemos un archivo de entrada que define los sitios que necesitan conectarse en grupo, podemos llevarlo a cabo. El siguiente script de PowerShell es un ejemplo que se puede ajustar a sus necesidades, ya que es posible que quiera más o menos elementos como parte de la conexión en grupo.

La versión de ejemplo compartida del script implementa los siguientes pasos:

Agrega al administrador de espacios empresariales actual como administrador del sitio cuando sea necesario: la conexión en grupo requiere una cuenta de usuario (no se puede incluir solo una aplicación).
Comprueba si la plantilla de sitio o la función de publicación usan e impiden la conexión en grupo, de acuerdo con la lógica del analizador.
Garantiza que no haya funciones habilitadas que bloqueen la interfaz moderna y, si las hay, las corrige.
Garantiza que la función de página moderna esté habilitada.
Opcional: implementa aplicaciones (por ejemplo, Personalizador de aplicación).
Opcional: agrega su propia página principal moderna.
Llama a la API de conexión en grupo.
Define los administradores y propietarios del sitio como los propietarios del grupo.
Define los miembros del sitio como miembros del grupo.
Quita los propietarios del sitio y el administrador de espacios empresariales agregados de los administradores de SharePoint.
Quita el administrador de espacios empresariales agregado del grupo de Microsoft 365.

La ejecución del siguiente script de PowerShell requiere que actualice la dirección URL del centro de administración de espacios empresariales y, en tiempo de ejecución, proporcione las credenciales y el archivo CSV de entrada.