By: Caio Ribeiro César

Este post faz referência ao artigo localizado neste link.

No final de Outubro (31/10/2017), o protocolo de RPC over HTTP será descontinuado no Exchange Online. O protocolo para comunicações via Outlook será substituído pelo MAPI/HTTP (disponível publicamente desde 2014).

Qual o motivo desta substituição? O protocolo MAPI over HTTP oferece diversas vantagens - as principais sendo a resiliência na conexão e suporte para Multi Fator Authentication (MFA).

Qual o impacto na sua organização?

• Se sua organização ainda utiliza o Outlook 2007, ele irá parar de funcionar. A conectividade não será efetuada, pois esta versão utiliza somente o protocolo antigo;
• Se você  possuir as versões 2010 ou 2013 e não tiver os updates instalados, a conectividade será perdida até que os updates sejam instalados;
• Caso você possua uma release mais atual com updates e o RPC over HTTP for anteriormente configurado via hardcode (registro; group policy object), o client Outlook perderá conexão.

Como resolver as questões acima?

1. Atualização do Outlook para a última release. Os builds mí­nimos são:

Lembrando que a versão de 2007 não possui atualização que efetue o backport do novo protocolo, sendo a atualização para uma versão mais recente (recomendada 2013 ou 2016) a única resolução.

Caso a versão esteja atualizada e o registro hardcoded para “MapiHttpDisabled = 1”, remova a entrada e reinicie o Outlook.

Existem algumas maneiras de se enumerar as versões de Outlook da sua organização. Conforme já discutido anteriormente, agora temos a possibilidade de auditar Mailbox Audit para Owners.

Sendo assim, o log de auditoria pode auxiliar na coleta de dados:

Set-Mailbox -Identity user@contoso.com -AuditOwner MailboxLogin -AuditEnabled $true

Search-MailboxAuditLog -Identity user@contoso.com -LogonTypes owner -ShowDetails | ? { $_.ClientInfoString -like "*Outlook*" }

Para todas as mailboxes:

Get-Mailbox | Set-Mailbox -AuditOwner MailboxLogin -AuditEnabled $true

Get-Mailbox | Search-MailboxAuditLog -LogonTypes owner -ShowDetails | ? { $_.ClientInfoString -like "*Outlook*" } | select MailboxOwnerUPN,Operation,LogonType,LastAccessed,ClientInfoString | export-csv .\OutlookConnections.csv

Obs.: Não é recomendado ter o log de auditoria para Owner habilitado por muito tempo, devido ao fato que o log é armazenado localmente na mailbox de cada usuário e irá utilizar o seu Recoverable Items Quota. Assim que tiver as informações, remova o AuditOwner das mailboxes:

Get-Mailbox | Set-Mailbox -AuditOwner MailboxLogin -AuditEnabled $false

¿Por que deprecamos el protocolo?
MAPI/HTTP ofrece numerosas ventajas respecto a su predecesor entre las cuales se destacan:

Listo para el futuro usando un protocolo basado en HTTP.

• Proporciona tiempos de reconexión más rápidos después de una interrupción de las comunicaciones porque solo se necesita reconstruir las conexiones TCP, no las conexiones RPC.
Algunos ejemplos de una interrupción de las comunicaciones son:

> Hibernación de dispositivos

>  Cambio de una red cableada a una red inalámbrica o móvil

• Ofrece un contexto de sesión que no depende de la conexión. El servidor mantiene el contexto de sesión durante un período de tiempo configurable, aunque el usuario cambie de red.

Como puede impactarme esto ?
•Si su organización utiliza Outlook 2007, no podrá conectarse a un buzón alojado en Exchange Online ya que dicho producto no soporta el protocolo MAPI/HTTP.

•Si su organización utiliza versiones posteriores como ser Outlook 2010, 2013 o 2016, debe asegurarse que las mismas contengan todas las actualizaciones al menos hasta Enero 2016.

•Versiones de Outlook 2010 o posteriores aceptan una modificación en el método de conexión el cual permitía seguir utilizando RPC/HTTP a través de una llave de registro, la misma debe ser removida ya que de lo contrario dichos clientes tampoco podrán conectar con buzones alojados en Exchange Online.

Como puedo resolver el inconveniente?

Actualizar Outlook a la versión más reciente:

Confirme que posee una de las versiones abajo listadas:
Office 2016 con la actualización del 8 de diciembre de 2015 16.0.6568.20xx MSI: 16.0.4312.1001
Office 2013 Office 2013 Service Pack 1 (SP1) con la actualización del 8 de diciembre de 2015 15.0.4779.1002
Office 2010 Office 2010 Service Pack 2 (SP2) con la actualización del 8 de diciembre de 2015 14.0.7164.5002

Para revisar como obtener esta información puede remitirse a ¿Qué versión de Outlook tengo?

Recuerde que la versión de Outlook 2007 no soporta el nuevo protocolo por lo cual inclusive teniendo las últimas actualizaciones no podremos utilizar Outlook 2007 para conectar con buzones en Exchange Online.

Si posee una versión de Outlook que soporta MAPI/HTTP (2010, 2013, 2016) valide y remueva si es necesario la llave de registro que fuerza la utilización de RPC/HTTP. Para más información puede consultar el articulo Outlook 2010, 2013 o 2016 no puede conectarse mediante MAPI a través de HTTPs, como se esperaba

También puede proactivamente colectar la información para identificar los clientes que están siendo utilizados para acceder al buzón del usuario mediante una auditoria al mismo.

Set-Mailbox -Identity user@contoso.com -AuditOwner MailboxLogin -AuditEnabled $true

Search-MailboxAuditLog -Identity user@contoso.com -LogonTypes owner -ShowDetails | ? { $_.ClientInfoString -like "*Outlook*" }

Para realizar el proceso de forma masiva Podemos hacer lo siguiente:

Get-Mailbox | Set-Mailbox -AuditOwner MailboxLogin -AuditEnabled $true

Get-Mailbox | Search-MailboxAuditLog -LogonTypes owner -ShowDetails | ? { $_.ClientInfoString -like "*Outlook*" } | select MailboxOwnerUPN,Operation,LogonType,LastAccessed,ClientInfoString | export-csv .\OutlookConnections.csv

Nota.: No se recomienda dejar la auditoria activada para Owner por la cantidad de logs que genera, por lo tanto, luego de obtener la información requerida se recomienda deshabilitar la misma.

Get-Mailbox | Set-Mailbox -AuditOwner MailboxLogin -AuditEnabled $false

Hola a todos,

Mi nombre es David Jaimes Castañeda, soy parte del equipo de soporte de Microsoft Latinoamérica. El siguiente articulo trata sobre un caso sobre problemas para realizar respaldos en un servidor por falta de espacio.

Contamos con un servidor físico corriendo sobre Windows Server 2012 R2 y que su único rol es realizar y albergar respaldos. El servidor cuenta con dos volúmenes C y D. El primero con un tamaño de 1 TB y el segundo con 4.5 TB. El volumen C cuenta con poco más de 900 GB de espacio libre y el volumen D con 4.3 TB de espacio libre.

El problema se presentaba al intentar crear un respaldo tipo BAREMETAL en el servidor sobre la unidad D, el error que se genera es el siguiente:

There is not enough disk space to create the volume shadow copy on the storage location. Make sure that, for all volumes to be backup up, the minimum required disk space for shadow copy creation is available. This applies to both the backup storage destination and volumes included in the backup. Minimum requirement: For volumes less than 500 megabytes, the minimum is 50 megabytes of free space. For volumes more than 500 megabytes, the minimum is 320 megabytes of free space. Recommended: At least 1 gigabyte of free disk space on each volume if volume size is more than 1 gigabyte.

Lo extraño de este problema radicaba que en la unidad donde se guardarían los respaldos contaba con poco más de 4 TB de espacio libre, entonces la pregunta era ¿Dónde está la falta de espacio que nos indica el mensaje de error?

Debido al mensaje enviado, lo primero a revisar fue el estatus del Shadow Storage con el afán de identificar un posible mal manejo de dicho espacio en los volúmenes. Encontramos que tanto el volumen D como el de recuperación no tenían un límite establecido, sin embargo, el uso del shadow storage era nulo:

PS C:\Users\administrator.CONTOSO> vssadmin list shadowstorage
vssadmin 1.1 - Volume Shadow Copy Service administrative command-line tool
(C) Copyright 2001-2013 Microsoft Corp.

Shadow Copy Storage association
For volume: (C:)\\?\Volume{99d0a077-1713-44bd-9fbb-4acc53eebc63}\
Shadow Copy Storage volume: (C:)\\?\Volume{99d0a077-1713-44bd-9fbb-4acc53eebc63}\
Used Shadow Copy Storage space: 0 bytes (0%)
Allocated Shadow Copy Storage space: 0 bytes (0%)
Maximum Shadow Copy Storage space: 10,0 GB (0%)

Shadow Copy Storage association
For volume: (D:)\\?\Volume{16488cef-11d4-4132-88b9-24e97e2c5a61}\
Shadow Copy Storage volume: (D:)\\?\Volume{16488cef-11d4-4132-88b9-24e97e2c5a61}\
Used Shadow Copy Storage space: 0 bytes (0%)
Allocated Shadow Copy Storage space: 0 bytes (0%)
Maximum Shadow Copy Storage space: UNBOUNDED (384250904%)

Shadow Copy Storage association
For volume: (\\?\Volume{fdfeba74-fe0f-4201-a06c-e275ee1eb265}\)\\?\Volume{fdfeba74-fe0f-4201-a06c-e275ee1eb265}\
Shadow Copy Storage volume: (\\?\Volume{fdfeba74-fe0f-4201-a06c-e275ee1eb265}\)\\?\Volume{fdfeba74-fe0f-4201-a06c-e27
5ee1eb265}\
Used Shadow Copy Storage space: 0 bytes (0%)
Allocated Shadow Copy Storage space: 0 bytes (0%)
Maximum Shadow Copy Storage space: UNBOUNDED (100%)

Revisando el visor de eventos, validamos que en efecto se genera un error al momento de reproducir el problema:

Log Name:     Application
Source:       Microsoft-Windows-Backup
Date:         11/07/2017 16:03:19
Event ID:     521
Task Category: None
Level:         Error
Keywords:    
User:         SYSTEM
Computer:     backuptest.contoso.local
Description:
The backup operation that started at '‎2017‎-‎07‎-‎11T19:03:09.922000000Z' has failed because the Volume Shadow Copy Service operation to create a shadow copy of the volumes being backed up failed with following error code '0x80780119'. Please review the event details for a solution, and then rerun the backup operation once the issue is resolved.

En los detalles del evento no se logró encontrar una causa que nos ayudase a resolver el problema, por ello decidí tomar una traza de VSS mientras se reprodujo el problema y al realizar el análisis se logró identificar un tiempo de espera en el writer de sistema:

<Writer _ElementDisplayName="System Writer" _ElementIcon="10"
WriterInstanceID="a442fdc0-8349-4d9e-9526-b276853f45cc"
WriterID="e8132975-6f93-4464-a53e-1050253ae220"
Status="VSS_WS_FAILED_AT_PREPARE_BACKUP" FailureCode="-2147212302"
FailureString="VSS_E_WRITERERROR_TIMEOUT">
<Event _ElementDisplayName="IDENTIFY (Enter) (11/07/2017 16:58:48.552)" _ElementIcon="5"
Writer="System Writer"
LastErrorCode="0x800423f2"
SnapshotSetID="{00000000-0000-0000-0000-000000000000}"
Timestamp="0x01d2fa801c591efd"
Process="1088" Thread="7356" State="7" Context="0x00000001"/>

La posible causa apuntaba a que una de las particiones a respaldar no contaba con espacio suficiente, la primera a revisar fue la partición de recuperación del sistema operativo. Para poder comprobarlo se asignó un punto de montura y así acceder a la partición deseada mediante diskpart:

Microsoft DiskPart version 6.3.9600

Copyright (C) 1999-2013 Microsoft Corporation.
On computer: backuptest

DISKPART> lis did

Disk ### Status         Size     Free     Dyn Gpt
-------- ------------- ------- ------- --- ---
Disk 0   Online        1117 GB     0 B       *
Disk 1   Online         4471 GB     0 B       *

DISKPART> sel dis 0

Disk 0 is now the selected disk.

DISKPART> lis par

Partition ### Type             Size     Offset
------------- ---------------- ------- -------
Partition 1   Recovery           300 MB 1024 KB
Partition 2   System             99 MB   301 MB
Partition 3   Reserved           128 MB   400 MB
Partition 4   Primary           1117 GB   528 MB

DISKPART> sel par 1

Partition 1 is now the selected partition.

DISKPART> assign letter = O

DiskPart successfully assigned the drive letter or mount point.

DISKPART> exit

Leaving DiskPart...

Accediendo a los archivos desde CMD logramos detectar que solo contaba con 31 MB de espacio libre y como lo indica el mensaje de error un volumen menor a 500 MB requiere, mínimo, 50 MB:

C:\>O:

O:\>dir /a
Volume in drive O is Recovery
Volume Serial Number is FE14-146B

Directory of O:\

04/07/2017 13:19    <DIR>         *************
24/03/2017 07:09   <DIR>         Recovery
04/07/2017 12:13   <DIR>         System Volume Information
0 File(s)             0 bytes
3 Dir(s)     31.711.232 bytes free

En este punto la primera opción para resolver el problema era recrear la partición para otorgar más espacio, sin embargo, de no ser exitoso el proceso el servidor podría quedar imposibilitado para arrancar. Al no haber una solución tan agresiva se decidió deshabilitar de manera temporal WinRE con el siguiente comando reagentc /disable con el afán de liberar espacio en la partición de recuperación

Microsoft Windows [Version 6.3.9600]
(c) 2013 Microsoft Corporation. All rights reserved.

C:\Windows\system32>reagentc /disable
REAGENTC.EXE: Operation Successful.
 
Ahora, debido a que los writers se encuentran en estado fallido o en tiempo de espera, tras el último intento fallido de hacer un respaldo, se debe reiniciar el servidor para sacarlos de dicha condición. ¡Una vez hecho eso se valida que el espacio libre de la partición de recuperación es de 231 MB por lo que se procede a realizar un intento de respaldo siendo este, EXITOSO!

Finalmente se habilita nuevamente WinRE con el comando abajo mencionado:

Microsoft Windows [Version 6.3.9600]
(c) 2013 Microsoft Corporation. All rights reserved.

C:\Windows\system32>reagentc /enable
REAGENTC.EXE: Operation Successful.

INFORMACION DE REFERENCIA:

• Understanding Disk Partitions
• Using Tracing Tools with VSS
• REAgentC Command-Line Options

Finalmente me resta agradecer al ingenierode nuestro equipo de escalacaciones Yabin Escarpulli por su apoyo y guia durante el proceso de resolucion de este problema.

Hola, mi nombre es Zahid Barrera y soy parte del equipo de Soporte de Microsoft , quiero compartirles parte de la experiencia que hemos tenido dentro del Equipo de  Soporte de Exchange respecto a la pregunta que muchos clientes nos hacen frecuentemente, ¿Cómo puedo reducir el tamaño de mi EDB?, mi disco se está terminando y me urge reducirle el espacio.

La pregunta que surge a muchos clientes es la siguiente: ¿Es la desfragmentación una opción viable y recomendada para reducir el espacio en disco?, la respuesta es NO, hay que considerar lo siguiente, como lo menciona el siguiente articulo (en inglés) https://blogs.technet.microsoft.com/exchange/2004/07/08/is-offline-defragmentation-considered-regular-exchange-maintenance/, consideremos lo siguiente.

¿Dónde es realmente necesaria una desfragmentación?

1. Si ha eliminado una gran cantidad de datos fuera de la tienda y desea recuperar el espacio en el disco duro por cualquier razón. Esto incluye situaciones en las que las bases de datos alcanzan el límite de 16 GB en las versiones estándar del servidor de Exchange.
2. Si tuviera que ejecutar un Hard Repair de la base de datos (eseutil / p - y eso es otra cosa que NO recomendamos a menos que sea una última cosa posible que hacer). Después de ejecutar una reparación, se debe siempre de realizar una desfragmentación fuera de línea de la base de datos para obtener un nuevo archivo de base de datos que no ha sido reparado.
3. Si está experimentando un problema específico y ha encontrado una referencia que dice que la desfragmentación sin conexión lo solucionará.
4. Si está trabajando con PSS y resolver el problema requiere una desfragmentación sin conexión.
5. Como regla general, sólo utilice desfragmentación para recuperar el espacio si se va a reclamar más del 30% del espacio.

ahora bien, es posible aplicar una desfragmentación cuando las opciones mencionadas no son viables, se puede aplicar Offiline desfragmentation (Desfragmentación fuera de línea) es decir se debe desmontar la base de datos para realizarlo, aunque existen otros métodos para reducir el espacio, y lo más recomendable es crear nuevas bases de datos para distribuir la carga de buzones en el servidor, les comparto el procedimiento para realizarlo.

1. Validamos el estado actual de la base de datos, en este caso "TestEDB".

2. Procedemos a desmontar la Base de Datos.

3. Como se observa la Base de datos TestEDB pesa casi 254 Mb originalmente.

4. Abrimos un Command Prompt con privilegios de Administrador, vamos a la ruta donde la base de datos se encuentra y escribimos ESEUTIL /D "basededatos.edb".

5. Validamos que la base de datos se reduce aproximadamente un 85% de espacio.

6. Después de esto es altamente recomendable realizar un respaldo completo de la base de datos (full backup).

7. Puede suceder que el catalogo momentáneamente se muestre como Failed, sin embargo al cabo de unos minutos volverá a su estado normal.

Luego entonces, la mejor manera de gestionar espacios en los discos respecto a tamaños de bases de datos, es ejecutando un buen plan de mantenimiento, eso en horas no laborables por supuesto.

Una cosa más ..

Como la base de datos es diferente en el otro nodo, se necesitará una reseed. Puede ser que versiones más recientes de Exchange  lo hagan automáticamente, pero si se tienen varias copias en una base de datos con gran tamaño, puede causar retrasos, debemos tomar en cuenta esto.

En este caso, realizar un Update-MailboxDatabaseCopy para recrear la copia.

https://blogs.technet.microsoft.com/rmilne/2013/08/23/offline-defrag-and-dag-databases-oh-my/

Espero esta información sea útil, si surgen más dudas por favor déjanos un comentario, o que mejor, contacta a tu siempre amigable Equipo de soporte Microsoft.

Aprovecho para agradecer al Ing. De Microsoft Eduardo Tavares, por su apoyo y asesoría en este artículo,

Hasta pronto…

By: Caio Ribeiro César

Este post faz referência aos artigos localizados nos links abaixo:

• How and when to decommission your on-premises Exchange servers in a hybrid deployment
• Decommissioning your Exchange 2010 servers in a Hybrid Deployment

Nossa equipe de suporte recebeu ao longo do tempo algumas mensagens mencionando um texto de um post anterior. Hoje, iremos explicar melhor o que foi informado:

Conforme já discutido em outros artigos, é importante ressaltar que a utilização da ferramenta “adsiedit” para a gerência de objetos do Exchange/Exchange Online não é algo suportado pela Microsoft. Temos um índice de clientes que efetuam o decommission do Exchange On-Premises após a migração para a nuvem e, logo após, solicitam a suportabilidade para a gerência de objetos com o adsiedit – ou até o cenário descrito abaixo. É uma prática que pode ser efetuada por administradores, porém a equipe de suporte não irá atuar em chamados com a utilização de AdsiEdit para o gerenciamento de objetos.

Recomendamos a instalação de ao menos um Exchange Server on-premises para a edição de atributos via Exchange Management Console / Exchange Control Panel.

Vamos primeiro analisar os tipos de migrações disponí­veis para o Exchange Online:

• Migração IMAP: Suporta uma variedade de plataformas diferentes, migração de dados (e-mail somente - não migramos calendários, contatos ou tarefas). Alguns exemplos são: Exchange Servers (com IMAP implementado), provedores de terceiros (Notes, GroupWise, Gmail, etc).
• Migração Cutover: Rápida e simples, não é necessário atualizar o ambiente on-premises para novas versões ou instalação de AADConnect. Suportada em ambientes de até 2.000 mailboxes nas versões de Exchange 2003, 2007, 2010, 2013 ou 2016.
• Migração Staged/em lotes: Nos dias atuais, raramente utilizada devido ao baixo número de clientes com 2.000 mailboxes migrando de versões 2003 ou 2007 que também possuem AADConnect.
• Migração Hí­brida: Método mais utilizado para a migração de mailboxes. Feita em etapas, esta migração é a opção caso o administrador queira gerenciar seus usuários on-premise e online. Possui funcionalidades adicionais tais como o acesso Cross-Premise, migração aperfeiçoada com melhor gerência de batches, simples offboard e Free/Busy. Geralmente escolhida por empresas com +2000 mailboxes - porém não é uma regra (desde que o ambiente esteja atualizado).
• Migração PST: Geralmente não listamos pst como um "métido" de migração em si. Alguns clientes optam pelo pst import, o motivo principal sendo o 3rd party não suportar IMAP. Recomendamos outros métodos, porém caso não exista a possibilidade, o upload utilizando um blob de Azure é o mais indicado.

Agora que sabemos um pouco mais sobre as opções, vamos ao cenário:

Ambiente Híbrido de Exchange 2013/2016, com a maior parte das mailboxes migradas para o Exchange Online. Assim que o último batch de migração terminar, o administrador deseja remover por completo o ambiente de Exchange On-Premises (eliminando assim os custos de servidores físicos).

As discussões mais comuns no suporte para este ambiente são:

1) Se o objetivo sempre foi um ambiente “full cloud” e a organização tiver um número de mailboxes inferior a 2.000, a melhor escolha inicial de migração seria cutover.
2) Caso o ambiente possua um número maior de 2.000 mailboxes, o método escolhido foi o rich mailbox move (Híbrido). Para que o ambiente se torne full cloud, o decommission é necessário. Antes de efetuar o decommission, algumas funcionalidades que serão perdidas: Archive On-Premises, Free Busy entre organizações e principalmente a possibilidade de gerenciar os objetos via Active Directory (AADConnect).

Caso o administrador do ambiente mencionado acima não precise da gerência de seus objetos no AD (ou seja, elas serão feitas diretamente no portal do O365), basta confirmar que todas as mailboxes/Public Folders já estão migradas e então remover o sincronismo de objetos e posteriormente o Exchange OnPremises seguindo o procedimento detalhado aqui.

E as organizações que precisam remover o ambiente On-Premises e ainda precisam da gerência de objetos no AD? Tais ambientes, como uma empresa que utiliza o ADFS para a federação, terão o sincronismo de objetos como um pré-requisito.

A recomendação para todos os clientes que ainda devem usar o AADConnect é de ter a instalação de ao menos um Exchange Server on-premises para a edição de atributos via Exchange Management Console / Exchange Control Panel.

Qual o motivo?

As organizações que implementaram um ambiente Híbrido, inicialmente utilizaram o AADConnect para o sincronismo de objetos: atributos de Exchange definem o status de objetos para migrações de mailboxes, mailflow e até de conectividade de Outlook.

Os ambientes de Federação seguem o mesmo padrão: o single sign on de um objeto só irá funcionar se o ADFS o identificar – para isto temos o sincronismo de dados onpremises e na cloud (object matching).

A implementação do sincronismo de objetos, efetua a alteração do Source of Authority (SoA): quando falamos de um ambiente sincronizado, o AD é o dono das informações que são populadas para os objetos no Azure Active Directory (AAD). Temos a necessidade uma gerência de objetos simples e objetiva com o AD, e por isso habilitamos os objetos como “sincronizados”.

Motivo: as alterações de objetos não podem ser feitas diretamente no Exchange Online (já que o SoA é o Active Directory). Caso o último Exchange Server seja removido, perdemos também a gerência de objetos nas ferramentas On-Premises (EAC/EMC) e a utilização de Adsiedit para tarefas administrativas não é suportada.

A equipe de suporte também entende o lado do administrador, que deseja cortar os gastos de servidores físicos. Para este fator, recomendamos a utilização do Azure como solução cloud (assim como possivelmente utilizado para o servidor AADConnect, ADFS, WAP).

A Microsoft oferece sem custos adicionais uma chave de Hybrid Server para as organizações - https://support.microsoft.com/en-us/help/2939261/how-to-obtain-an-exchange-hybrid-edition-product-key-for-your-on-premi

By: Caio Ribeiro César

Olá, publicamos no nosso canal de YouTube um vídeo com uma pequena demonstração do aplicativo Kaizala e o portal de gerenciamento.

Vale a pena conferir!

By: Fabiano Mira
We know that using large lists with SharePoint Online can cause some problems due the 5000 item List View Threshold, and it is completely understandable why this limit exists, it´s to minimize database contention SQL Server, the back-end database for SharePoint, often uses row-level locking as a strategy to ensure accurate updates without adversely impacting other users who are accessing other rows.
There are several ways to manage large lists that can be find in this article:

Manage large lists and libraries in SharePoint
https://support.office.com/en-us/article/Manage-large-lists-and-libraries-in-SharePoint-B8588DAE-9387-48C2-9248-C24122F07C59

Just in case you get throttled and the list become instable or you can´t access it anymore to create your views you can clean the items to open the list again.
Usually this applies to historical lists where the data can be erased.
Here it is an CSOM PowerShell Script that you can easily use to delete all list items on a bulk operation.

#Change here with your local path with SP DLLs downloaded from SP Framerwork
Import-Module 'C:\temp\SharePoint Online Client Browser v2.2\Microsoft.SharePoint.Client.dll'
Import-Module 'C:\temp\SharePoint Online Client Browser v2.2\Microsoft.SharePoint.Client.Runtime.dll'
Add-Type -Path 'C:\temp\SharePoint Online Client Browser v2.2\Microsoft.SharePoint.Client.dll'


$site = ''
$admin = ''

$password = Read-Host 'Enter Password' -AsSecureString

$context = New-Object Microsoft.SharePoint.Client.ClientContext($site)
$credentials = New-Object Microsoft.SharePoint.Client.SharePointOnlineCredentials($admin , $password)
$context.Credentials = $credentials


$list = $context.Web.Lists.GetByTitle('')
$context.Load($list)
$context.ExecuteQuery()
$count = $list.ItemCount

$newline = [environment]::newline
Write-Host -NoNewline "Deleting listitems" -foregroundcolor black -backgroundcolor yellow
$continue = $true
while($continue)
{
    Write-Host -NoNewline "." -foregroundcolor black -backgroundcolor yellow
    $query = [Microsoft.SharePoint.Client.CamlQuery]::CreateAllItemsQuery(100, "ID")
    $listItems = $list.GetItems( $query )
    $context.Load($listItems)
    $context.ExecuteQuery()
    if ($listItems.Count -gt 0)
    {
        for ($i = $listItems.Count-1; $i -ge 0; $i--)
        {
            $listItems[$i].DeleteObject()
        }
        $clientContext.ExecuteQuery()
    }
    else
    {
        Write-Host "." -foregroundcolor black -backgroundcolor yellow
        $continue = $false;
    }
}
Write-Host "All listitems deleted from Pages." -foregroundcolor black -backgroundcolor green

By: Caio Ribeiro César e César Augusto Hara

Com o aumento da utilização do Outlook 2016, mais organizações estão utilizando a funcionalidade de Modern Authentication. O que é o Modern Authentication?

Para entender o Modern Authentication, vamos primeiro explicar quais são os outros métodos de autenticação, também conhecidos como “legacy”, disponíveis para o O365.

1 - Autenticação Ativa (WSTRUST)

Modelo de autenticação utilizado por versões mais antigas de Outlook (2010 + 2013 sem as atualizações necessárias) ou até protocolos como ActiveSync, POP3, IMAP, SMTP.

O Exchange Online é o responsável pela comunicação com o Identity Provider (ADFS). O Outlook em si não faz parte do processo de autenticação, apenas dos resultados do processo. Já discutimos anteriormente neste post, porém vamos revisar de uma maneira mais simples:

• Usuário final faz o request para a utilização de um recurso no Exchange Online (Ol2010);
• Exchange Online faz o pedido de credencial;
• O usuário adiciona a informação para a autenticação (usuário e senha). Estas informações são armazenadas pelo Exchange Online;
• Exchange Online faz o contato com o OrgID (O365). Se a conta é comum/cloud, o usuário é autenticado – caso contrário seguimos com o passo de autenticação ativa e a comunicação é redirecionada para o Identity Provider (ADFS);
• Exchange Online faz contato com o IDP;
• O SAML token é enviado do IDP para o Exchange Online;
• Exchange Online envia o SAML token para o OrgId;
• OrgId retorna o O365 token;
• Exchange Online consome o token e concede acesso para o usuário final.

2 - Autenticação Passiva (WSFED)

Modelo mais simples de autenticação, utilizado no OWA e no Portal. Cada passo de autenticação é exposto para o cliente (browser).

• Usuário efetua o acesso para o OWA sem estar logado (importante lembrar que usuários utilizando um cookie persistente com o keep me signed não terão que readicionar as informações de login);
• OWA efetua o redirecionamento para o OrgID (login.microsoftonline.com);
• O usuário adiciona o User Principal Name. Como estamos falando de um ambiente federado, assim que o usuário selecionar a opção de senha, o browser irá redirecionar para a página de acesso “\adfs\ls” da organização;
• Usuário insere as credenciais;
• O Identity Provider retorna o SAML token para o browser e efetua o redirecionamento para o OrgId;
• Browser efetua um POST do Token para o OrgId, que retorna um cookie de autenticação;
• Com o cookie, o browser acessa o OWA.

Por ser um modelo mais simples, o troubleshoot geralmente é feito apenas com traces de Fiddler.

Explicamos para os engenheiros de suporte que o processo em si pode ser explicado com apenas uma imagem:

Brincadeiras a parte, vamos ao último método de autenticação!

3 - Modern Authentication

O modelo “moderno” de autenticação já é utilizado por muitos de nossos clientes de O365. Também conhecido como “OAuth” ou “ADAL”, utiliza as bibliotecas de autenticação do ADAL (Azure Active Directory Authentication Libraries). Quem lida com o processo de autenticação não é o Exchange Online, e sim o Cliente (Outlook).

Para validar se a sua organização possui o Modern Authentication habilitado, basta executar o procedimento via PowerShell.

Get-OrganizationConfig | fl *oau*

Caso o resultado seja “False”, execute o comando:

Set-OrganizationConfig - OAuth2ClientProfileEnabled $True

Vale ressaltar que as conexões não serão forçadas para Modern Authentication. Se a sua organização ainda possui clientes que utilizam a autenticação Ativa, as comunicações não serão afetadas (iremos apenas aceitar Modern Auth para as versões abaixo).

As versões que suportam este modelo são:

• Outlook 2016 + Outlook 2016 for Mac (15.20);
• Outlook Mobile para IOS/Android;
• PowerShell;
• Outlook 2013, desde que:

a) A versão esteja atualizada. O requerimento mínimo é 15.0.4701, porém sempre recomendamos a última release do produto.

b) O Outlook tenha esta configuração manualmente ativada (hardcoded) no registro:

HKCU\SOFTWARE\Microsoft\Office\15.0\Common\Identity\EnableADAL
REG_DWORD 1

HKCU\SOFTWARE\Microsoft\Office\15.0\Common\Identity\Version
REG_DWORD 1

• Usuário acessa o Outlook, que faz o query autodiscover + conexão para o ExO;
• Exchange Online envia um “401”: token necessário para conexão Outlook;
• Outlook envia um “GET” realm pra o O365, que responde com a informação do STS (Identity Provider);
• Outlook entra em contato com o IDP (sts.domain.com);
• Outlook recebe o prompt de autenticação do IDP;
• A credencial é inserida e enviada ao IDP;
• SAML token enviado do IDP para o Outlook;
• POST do token efetuado do Outlook para o O365;
• Refresh token enviado do O365 para o Outlook;
• Acesso garantido Outlook <> Exchange Online.

Dicas de troubleshooting para Modern Authentication

1) Fiddler

O Fiddler trace ajuda a entender as etapas de autenticação. Geralmente, filtramos para o que ocorre durante ou após o “401”:

x-ms-diagnostics: 4000000;reason="Flighting is not enabled for domain contoso.com.";error_category="oauth_not_available"
trusted_issuers="", error="invalid_token"

2) Credential Manager

Como a autenticação é “trabalhada” pelo Outlook, as credenciais podem ser removidas manualmente via “Control Panel\User Accounts\Credential Manager\Windows Credentials”:

* Os tokens estão localizados em:

HKEY_CURRENT_USER\Software\Microsoft\Office\16.0\Common\Identity\Identities

By: Ricardo Viana

Some customers engage support by asking how to export specific folders to pst files.

Ediscovery can help you to achieve exporting the entire mailbox, and will not query Exchange Online Archive.

Support Engineer Ricardo Viana from O365 LATAM has built this script in order to export a single mailbox folder from Office365.

The script will map folder id's of selected mailbox and create a content search of all items in it. You can then download your results on Security and Compliance Center > Content Search.

Download the script here!

THIS CODE AND ANY ASSOCIATED INFORMATION ARE PROVIDED “AS IS” WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK OF USE, INABILITY TO USE, OR RESULTS FROM THE USE OF THIS CODE REMAINS WITH THE USER.

$Loop = $true
While ($Loop)
{
    write-host
    write-host +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    write-host   "Exchange Online Foler Export - Script menu"
    write-host +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    write-host
	write-host -ForegroundColor green '----------------------------------------------------------------------------------------------'
    write-host -ForegroundColor white  -BackgroundColor DarkGreen   'SECTION A:  Create a PST of one or more folders           '
    write-host -ForegroundColor green '----------------------------------------------------------------------------------------------'
    write-host                                              ' 1)  Create a PST from a mailbox '
	write-host                                              ' 2)  Create a PST from an archive '
    write-host
    write-host -ForegroundColor green  '----------------------------------------------------------------------------------------------'
    write-host -ForegroundColor white  -BackgroundColor DarkRed 'End of PowerShell - Script menu '
    write-host -ForegroundColor green  '----------------------------------------------------------------------------------------------'
    write-host -ForegroundColor Yellow            "3)  Exit the PowerShell script menu"
    write-host

    $opt = Read-Host "Select an option [1-3]"
    write-host $opt
    switch ($opt)


{



1
{
$email = Read-Host "Enter an email address"

if (!$credentials)
{
    $credentials = Get-Credential
}

if ($email.IndexOf("@") -ige 0)
{

    $emailAddress = $email


    if (!$ExoSession)
    {
        $ExoSession = New-PSSession -ConfigurationName Microsoft.Exchange -ConnectionUri https://ps.outlook.com/powershell-liveid/ -Credential $credentials -Authentication Basic -AllowRedirection
        Import-PSSession $ExoSession -AllowClobber -DisableNameChecking
    }

    $folderQueries = @()
    $folderStatistics = Get-MailboxFolderStatistics $emailAddress
    foreach ($folderStatistic in $folderStatistics)
    {
        $folderId = $folderStatistic.FolderId;
        $folderPath = $folderStatistic.FolderPath;
        $foldersize = $folderStatistic.Foldersize;
        $folderitems = $folderStatistic.ItemsInFolder;

        $encoding= [System.Text.Encoding]::GetEncoding("us-ascii")
        $nibbler= $encoding.GetBytes("0123456789ABCDEF");
        $folderIdBytes = [Convert]::FromBase64String($folderId);
        $indexIdBytes = New-Object byte[] 48;
        $indexIdIdx=0;
        $folderIdBytes | select -skip 23 -First 24 | %{$indexIdBytes[$indexIdIdx++]=$nibbler[$_ -shr 4];$indexIdBytes[$indexIdIdx++]=$nibbler[$_ -band 0xF]}
        $folderQuery = "folderid:$($encoding.GetString($indexIdBytes))";

        $folderStat = New-Object PSObject
        Add-Member -InputObject $folderStat -MemberType NoteProperty -Name FolderPath -Value $folderPath
        Add-Member -InputObject $folderStat -MemberType NoteProperty -Name FolderQuery -Value $folderQuery
        Add-Member -InputObject $folderStat -MemberType NoteProperty -Name Foldersize -Value $Foldersize
        Add-Member -InputObject $folderStat -MemberType NoteProperty -Name ItemsInFolder -Value $folderitems

        $folderQueries += $folderStat
    }
    Write-Host "-----Select Folders-----"
    $folderid2= $folderQueries | Out-GridView -OutputMode Multiple -Title 'Select folder/s:'
}

    Write-host "Folder selected:",$folderid2.folderpath
    $searchName = "Search"
    $searchActionName = "Search_Preview"


    if (!$SccSession)
    {
        $SccSession = New-PSSession -ConfigurationName Microsoft.Exchange -ConnectionUri https://ps.compliance.protection.outlook.com/powershell-liveid -Credential $credentials -Authentication Basic -AllowRedirection
        Import-PSSession $SccSession -AllowClobber -DisableNameChecking
    }


    Remove-ComplianceSearch $searchName -Confirm:$false -ErrorAction 'SilentlyContinue'


    $complianceSearch = New-ComplianceSearch -Name $searchName -ContentMatchQuery $folderid2.folderquery -ExchangeLocation "$email"
    Start-ComplianceSearch $searchName
    do{
        Write-host "Waiting for search to complete..."
        Start-Sleep -s 5
        $complianceSearch = Get-ComplianceSearch $searchName
    }while ($complianceSearch.Status -ne 'Completed')


    if ($complianceSearch.Items -gt 0)
    {
        # Create a Complinace Search Action and wait for it to complete. The folders will be listed in the .Results parameter
        $complianceSearchAction = New-ComplianceSearchaction -SearchName $searchName -Preview
        do
        {
            Write-host "Waiting for search action to complete..."
            Start-Sleep -s 5
            $complianceSearchAction = Get-ComplianceSearchAction $searchActionName
        }while ($complianceSearchAction.Status -ne 'Completed')


        $results = Get-ComplianceSearch -Identity $complianceSearchAction.EstimateSearchRunId |select successresults
        $results= $results -replace "@{SuccessResults={", "" -replace "}}",""
        $results -match "size:","(\d+)"
        $match= $matches[1]
        $matchmb= $match/1Mb
        $matchGb= $match/1Gb
        Write-Host "------------------------"
        Write-Host "Results"
        Write-Host "------------------------"
        Write-Host "$results"
        Write-Host "------------------------"
        Write-Host "Found Size"
        Write-Host "$matchmb","Mb"
        Write-Host "$matchGb","Gb"
        Write-Host "________________________"
        Write-Host -foregroundcolor green "Success"
        Write-Host "________________________"
        Write-Host "go to https://protection.office.com/#/contentsearch and export your PST"
        write-host
        write-host
        Read-Host "Press Enter to get back to the menu..."
        write-host
        write-host
        }
        }
2
{
$email = Read-Host "Enter an email address"

if (!$credentials)
{
    $credentials = Get-Credential
}

if ($email.IndexOf("@") -ige 0)
{

    $emailAddress = $email


    if (!$ExoSession)
    {
        $ExoSession = New-PSSession -ConfigurationName Microsoft.Exchange -ConnectionUri https://ps.outlook.com/powershell-liveid/ -Credential $credentials -Authentication Basic -AllowRedirection
        Import-PSSession $ExoSession -AllowClobber -DisableNameChecking
    }

    $folderQueries = @()
    $folderStatistics = Get-MailboxFolderStatistics $emailAddress -Archive
    foreach ($folderStatistic in $folderStatistics)
    {
        $folderId = $folderStatistic.FolderId;
        $folderPath = $folderStatistic.FolderPath;

        $encoding= [System.Text.Encoding]::GetEncoding("us-ascii")
        $nibbler= $encoding.GetBytes("0123456789ABCDEF");
        $folderIdBytes = [Convert]::FromBase64String($folderId);
        $indexIdBytes = New-Object byte[] 48;
        $indexIdIdx=0;
        $folderIdBytes | select -skip 23 -First 24 | %{$indexIdBytes[$indexIdIdx++]=$nibbler[$_ -shr 4];$indexIdBytes[$indexIdIdx++]=$nibbler[$_ -band 0xF]}
        $folderQuery = "folderid:$($encoding.GetString($indexIdBytes))";

        $folderStat = New-Object PSObject
        Add-Member -InputObject $folderStat -MemberType NoteProperty -Name FolderPath -Value $folderPath
        Add-Member -InputObject $folderStat -MemberType NoteProperty -Name FolderQuery -Value $folderQuery

        $folderQueries += $folderStat
    }
    Write-Host "-----Select Folders-----"
    $folderid2= $folderQueries | Out-GridView -OutputMode Multiple -Title 'Select folder/s:'
}

    Write-host "Folder selected:",$folderid2.folderpath
    $searchName = "Search"
    $searchActionName = "Search_Preview"


    if (!$SccSession)
    {
        $SccSession = New-PSSession -ConfigurationName Microsoft.Exchange -ConnectionUri https://ps.compliance.protection.outlook.com/powershell-liveid -Credential $credentials -Authentication Basic -AllowRedirection
        Import-PSSession $SccSession -AllowClobber -DisableNameChecking
    }


    Remove-ComplianceSearch $searchName -Confirm:$false -ErrorAction 'SilentlyContinue'


    $complianceSearch = New-ComplianceSearch -Name $searchName -ContentMatchQuery $folderid2.folderquery -ExchangeLocation "$email"
    Start-ComplianceSearch $searchName
    do{
        Write-host "Waiting for search to complete..."
        Start-Sleep -s 5
        $complianceSearch = Get-ComplianceSearch $searchName
    }while ($complianceSearch.Status -ne 'Completed')


    if ($complianceSearch.Items -gt 0)
    {
        # Create a Complinace Search Action and wait for it to complete. The folders will be listed in the .Results parameter
        $complianceSearchAction = New-ComplianceSearchaction -SearchName $searchName -Preview
        do
        {
            Write-host "Waiting for search action to complete..."
            Start-Sleep -s 5
            $complianceSearchAction = Get-ComplianceSearchAction $searchActionName
        }while ($complianceSearchAction.Status -ne 'Completed')


        $results = Get-ComplianceSearch -Identity $complianceSearchAction.EstimateSearchRunId |select successresults
        $results= $results -replace "@{SuccessResults={", "" -replace "}}",""
        $results -match "size:","(\d+)"
        $match= $matches[1]
        $matchmb= $match/1Mb
        $matchGb= $match/1Gb
        Write-Host "------------------------"
        Write-Host "Results"
        Write-Host "------------------------"
        Write-Host "$results"
        Write-Host "------------------------"
        Write-Host "Found Size"
        Write-Host "$matchmb","Mb"
        Write-Host "$matchGb","Gb"
        Write-Host "________________________"
        Write-Host -foregroundcolor green "Success"
        Write-Host "________________________"
        Write-Host "go to https://protection.office.com/#/contentsearch and export your PST"
        write-host
        write-host
        Read-Host "Press Enter to get back to the menu..."
        write-host
        write-host


        }
        }

3
{
$Loop = $true
Exit
}
}
}

Alguns clientes entram em contato com o suporte perguntando como exportar pastas específicas para arquivos ".pst".

O engenheiro de Suporte O365 Ricardo Viana criou o script abaixo para que você possa efetuar esta tarefa. Nesta nova versão. também efetuamos a exportação de dados do Exchange Online Archive.

O script irá mapear os folder id's das mailboxes em questão e então efetuar o content search para os items de cada pastas. Você poderá então baixar os resultados no Security & Compliance Center (SCC> Content Search).

O script está localizado aqui!

THIS CODE AND ANY ASSOCIATED INFORMATION ARE PROVIDED “AS IS” WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK OF USE, INABILITY TO USE, OR RESULTS FROM THE USE OF THIS CODE REMAINS WITH THE USER.

$Loop = $true
While ($Loop)
{
    write-host
    write-host +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    write-host   "Exchange Online Foler Export - Script menu"
    write-host +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    write-host
	write-host -ForegroundColor green '----------------------------------------------------------------------------------------------'
    write-host -ForegroundColor white  -BackgroundColor DarkGreen   'SECTION A:  Create a PST of one or more folders           '
    write-host -ForegroundColor green '----------------------------------------------------------------------------------------------'
    write-host                                              ' 1)  Create a PST from a mailbox '
	write-host                                              ' 2)  Create a PST from an archive '
    write-host
    write-host -ForegroundColor green  '----------------------------------------------------------------------------------------------'
    write-host -ForegroundColor white  -BackgroundColor DarkRed 'End of PowerShell - Script menu '
    write-host -ForegroundColor green  '----------------------------------------------------------------------------------------------'
    write-host -ForegroundColor Yellow            "3)  Exit the PowerShell script menu"
    write-host

    $opt = Read-Host "Select an option [1-3]"
    write-host $opt
    switch ($opt)


{



1
{
$email = Read-Host "Enter an email address"

if (!$credentials)
{
    $credentials = Get-Credential
}

if ($email.IndexOf("@") -ige 0)
{

    $emailAddress = $email


    if (!$ExoSession)
    {
        $ExoSession = New-PSSession -ConfigurationName Microsoft.Exchange -ConnectionUri https://ps.outlook.com/powershell-liveid/ -Credential $credentials -Authentication Basic -AllowRedirection
        Import-PSSession $ExoSession -AllowClobber -DisableNameChecking
    }

    $folderQueries = @()
    $folderStatistics = Get-MailboxFolderStatistics $emailAddress
    foreach ($folderStatistic in $folderStatistics)
    {
        $folderId = $folderStatistic.FolderId;
        $folderPath = $folderStatistic.FolderPath;
        $foldersize = $folderStatistic.Foldersize;
        $folderitems = $folderStatistic.ItemsInFolder;

        $encoding= [System.Text.Encoding]::GetEncoding("us-ascii")
        $nibbler= $encoding.GetBytes("0123456789ABCDEF");
        $folderIdBytes = [Convert]::FromBase64String($folderId);
        $indexIdBytes = New-Object byte[] 48;
        $indexIdIdx=0;
        $folderIdBytes | select -skip 23 -First 24 | %{$indexIdBytes[$indexIdIdx++]=$nibbler[$_ -shr 4];$indexIdBytes[$indexIdIdx++]=$nibbler[$_ -band 0xF]}
        $folderQuery = "folderid:$($encoding.GetString($indexIdBytes))";

        $folderStat = New-Object PSObject
        Add-Member -InputObject $folderStat -MemberType NoteProperty -Name FolderPath -Value $folderPath
        Add-Member -InputObject $folderStat -MemberType NoteProperty -Name FolderQuery -Value $folderQuery
        Add-Member -InputObject $folderStat -MemberType NoteProperty -Name Foldersize -Value $Foldersize
        Add-Member -InputObject $folderStat -MemberType NoteProperty -Name ItemsInFolder -Value $folderitems

        $folderQueries += $folderStat
    }
    Write-Host "-----Select Folders-----"
    $folderid2= $folderQueries | Out-GridView -OutputMode Multiple -Title 'Select folder/s:'
}

    Write-host "Folder selected:",$folderid2.folderpath
    $searchName = "Search"
    $searchActionName = "Search_Preview"


    if (!$SccSession)
    {
        $SccSession = New-PSSession -ConfigurationName Microsoft.Exchange -ConnectionUri https://ps.compliance.protection.outlook.com/powershell-liveid -Credential $credentials -Authentication Basic -AllowRedirection
        Import-PSSession $SccSession -AllowClobber -DisableNameChecking
    }


    Remove-ComplianceSearch $searchName -Confirm:$false -ErrorAction 'SilentlyContinue'


    $complianceSearch = New-ComplianceSearch -Name $searchName -ContentMatchQuery $folderid2.folderquery -ExchangeLocation "$email"
    Start-ComplianceSearch $searchName
    do{
        Write-host "Waiting for search to complete..."
        Start-Sleep -s 5
        $complianceSearch = Get-ComplianceSearch $searchName
    }while ($complianceSearch.Status -ne 'Completed')


    if ($complianceSearch.Items -gt 0)
    {
        # Create a Complinace Search Action and wait for it to complete. The folders will be listed in the .Results parameter
        $complianceSearchAction = New-ComplianceSearchaction -SearchName $searchName -Preview
        do
        {
            Write-host "Waiting for search action to complete..."
            Start-Sleep -s 5
            $complianceSearchAction = Get-ComplianceSearchAction $searchActionName
        }while ($complianceSearchAction.Status -ne 'Completed')


        $results = Get-ComplianceSearch -Identity $complianceSearchAction.EstimateSearchRunId |select successresults
        $results= $results -replace "@{SuccessResults={", "" -replace "}}",""
        $results -match "size:","(\d+)"
        $match= $matches[1]
        $matchmb= $match/1Mb
        $matchGb= $match/1Gb
        Write-Host "------------------------"
        Write-Host "Results"
        Write-Host "------------------------"
        Write-Host "$results"
        Write-Host "------------------------"
        Write-Host "Found Size"
        Write-Host "$matchmb","Mb"
        Write-Host "$matchGb","Gb"
        Write-Host "________________________"
        Write-Host -foregroundcolor green "Success"
        Write-Host "________________________"
        Write-Host "go to https://protection.office.com/#/contentsearch and export your PST"
        write-host
        write-host
        Read-Host "Press Enter to get back to the menu..."
        write-host
        write-host
        }
        }
2
{
$email = Read-Host "Enter an email address"

if (!$credentials)
{
    $credentials = Get-Credential
}

if ($email.IndexOf("@") -ige 0)
{

    $emailAddress = $email


    if (!$ExoSession)
    {
        $ExoSession = New-PSSession -ConfigurationName Microsoft.Exchange -ConnectionUri https://ps.outlook.com/powershell-liveid/ -Credential $credentials -Authentication Basic -AllowRedirection
        Import-PSSession $ExoSession -AllowClobber -DisableNameChecking
    }

    $folderQueries = @()
    $folderStatistics = Get-MailboxFolderStatistics $emailAddress -Archive
    foreach ($folderStatistic in $folderStatistics)
    {
        $folderId = $folderStatistic.FolderId;
        $folderPath = $folderStatistic.FolderPath;

        $encoding= [System.Text.Encoding]::GetEncoding("us-ascii")
        $nibbler= $encoding.GetBytes("0123456789ABCDEF");
        $folderIdBytes = [Convert]::FromBase64String($folderId);
        $indexIdBytes = New-Object byte[] 48;
        $indexIdIdx=0;
        $folderIdBytes | select -skip 23 -First 24 | %{$indexIdBytes[$indexIdIdx++]=$nibbler[$_ -shr 4];$indexIdBytes[$indexIdIdx++]=$nibbler[$_ -band 0xF]}
        $folderQuery = "folderid:$($encoding.GetString($indexIdBytes))";

        $folderStat = New-Object PSObject
        Add-Member -InputObject $folderStat -MemberType NoteProperty -Name FolderPath -Value $folderPath
        Add-Member -InputObject $folderStat -MemberType NoteProperty -Name FolderQuery -Value $folderQuery

        $folderQueries += $folderStat
    }
    Write-Host "-----Select Folders-----"
    $folderid2= $folderQueries | Out-GridView -OutputMode Multiple -Title 'Select folder/s:'
}

    Write-host "Folder selected:",$folderid2.folderpath
    $searchName = "Search"
    $searchActionName = "Search_Preview"


    if (!$SccSession)
    {
        $SccSession = New-PSSession -ConfigurationName Microsoft.Exchange -ConnectionUri https://ps.compliance.protection.outlook.com/powershell-liveid -Credential $credentials -Authentication Basic -AllowRedirection
        Import-PSSession $SccSession -AllowClobber -DisableNameChecking
    }


    Remove-ComplianceSearch $searchName -Confirm:$false -ErrorAction 'SilentlyContinue'


    $complianceSearch = New-ComplianceSearch -Name $searchName -ContentMatchQuery $folderid2.folderquery -ExchangeLocation "$email"
    Start-ComplianceSearch $searchName
    do{
        Write-host "Waiting for search to complete..."
        Start-Sleep -s 5
        $complianceSearch = Get-ComplianceSearch $searchName
    }while ($complianceSearch.Status -ne 'Completed')


    if ($complianceSearch.Items -gt 0)
    {
        # Create a Complinace Search Action and wait for it to complete. The folders will be listed in the .Results parameter
        $complianceSearchAction = New-ComplianceSearchaction -SearchName $searchName -Preview
        do
        {
            Write-host "Waiting for search action to complete..."
            Start-Sleep -s 5
            $complianceSearchAction = Get-ComplianceSearchAction $searchActionName
        }while ($complianceSearchAction.Status -ne 'Completed')


        $results = Get-ComplianceSearch -Identity $complianceSearchAction.EstimateSearchRunId |select successresults
        $results= $results -replace "@{SuccessResults={", "" -replace "}}",""
        $results -match "size:","(\d+)"
        $match= $matches[1]
        $matchmb= $match/1Mb
        $matchGb= $match/1Gb
        Write-Host "------------------------"
        Write-Host "Results"
        Write-Host "------------------------"
        Write-Host "$results"
        Write-Host "------------------------"
        Write-Host "Found Size"
        Write-Host "$matchmb","Mb"
        Write-Host "$matchGb","Gb"
        Write-Host "________________________"
        Write-Host -foregroundcolor green "Success"
        Write-Host "________________________"
        Write-Host "go to https://protection.office.com/#/contentsearch and export your PST"
        write-host
        write-host
        Read-Host "Press Enter to get back to the menu..."
        write-host
        write-host


        }
        }

3
{
$Loop = $true
Exit
}
}
}

Es sabido que el uso de listas largas puede provocar algunos problemas debido al límite de 5000 elementos de una vista, y el hecho de que este límite exista es totalmente comprensible: El objetivo es minimizar el bloqueo de la base de datos en el servidor de SQL, la base de datos propia de SharePoint. Éste utiliza un bloqueo a nivel registro como estrategia para asegurar actualizaciones en él sin impactar negativamente a otros usuarios que estén accediéndolo.

Existen otras maneras de manejar listas largas, las cuales pueden verse en este artículo:

Administrar listas y bibliotecas grandes en SharePoint

En el caso de enfrentarse con una situación en donde una lista o biblioteca hayan excedido este límite y no se tenga la necesidad de mantener toda la información en ella (tal es el caso de listas de tareas, workflows, históricos, etc), y la visualizacion por el navegador no sea posible y no tengamos forma de poder crear vistas, podemos usar una alternativa CSOM para eliminar los items y poder crear o editar las vistas y así evitar nuevamente este problema. Es importante hacer notar que esto aplica principalmente para listas o bibliotecas de históricos donde la información pueda ser borrada sin riesgo para la empresa.

A continuación se muestra el código de PowerShell CSOM y así poder eliminar de forma masiva los elementos de las bibliotecas o listas.

#Adapta la ruta para apuntar a las librerías de SharePoint (dll) que pueden descargarse desde SP Framerwork
Import-Module 'C:\temp\SharePoint Online Client Browser v2.2\Microsoft.SharePoint.Client.dll'
Import-Module 'C:\temp\SharePoint Online Client Browser v2.2\Microsoft.SharePoint.Client.Runtime.dll'
Add-Type -Path 'C:\temp\SharePoint Online Client Browser v2.2\Microsoft.SharePoint.Client.dll'


$site = ''
$admin = ''

$password = Read-Host 'Enter Password' -AsSecureString

$context = New-Object Microsoft.SharePoint.Client.ClientContext($site)
$credentials = New-Object Microsoft.SharePoint.Client.SharePointOnlineCredentials($admin , $password)
$context.Credentials = $credentials


$list = $context.Web.Lists.GetByTitle('')
$context.Load($list)
$context.ExecuteQuery()
$count = $list.ItemCount

$newline = [environment]::newline
Write-Host -NoNewline "Eliminando elementos de la lista " -foregroundcolor black -backgroundcolor yellow
$continue = $true
while($continue)
{
    Write-Host -NoNewline "." -foregroundcolor black -backgroundcolor yellow
    $query = [Microsoft.SharePoint.Client.CamlQuery]::CreateAllItemsQuery(100, "ID")
    $listItems = $list.GetItems( $query )
    $context.Load($listItems)
    $context.ExecuteQuery()
    if ($listItems.Count -gt 0)
    {
        for ($i = $listItems.Count-1; $i -ge 0; $i--)
        {
            $listItems[$i].DeleteObject()
        }
        $clientContext.ExecuteQuery()
    }
    else
    {
        Write-Host "." -foregroundcolor black -backgroundcolor yellow
        $continue = $false;
    }
}
Write-Host "Se han eliminado todos los listitems." -foregroundcolor black -backgroundcolor green

Por: Marcela Chitiva.

Un escenario común de Office 365 y OneDrive For Business que podemos encontrar, es que el administrador necesita recuperar la información de un sitio personal de OneDrive For Business de un usuario que ya no hace parte de la organización o que fue removido / eliminado de Office 365.

En este caso, podemos asignar como administrador del sitio una cuenta activa de Office 365.

Puntos a tener en cuenta:

• El sitio debe estar activo. Cuando se elimina el usuario del Tenant, el sitio se mantiene activo por defecto 30 días después.

• Se recomienda asignar como administrador del sitio alguna cuenta de administración de Office 365.

• El procedimiento se realiza a través de la Consola de Administración de SharePoint Online. Se puede descargar AQUI
  

Procedimiento:

Nos conectamos al Sitio de Administración de SharePoint Online:

Connect-SPOService –Url “Sitio de administración de SPO”

La colección de sitios de administración es la que tiene el sufijo “-admin”

Allí se abrirá una ventana para poner nuestras credenciales de administrador:

Ejecutamos el siguiente comando:

Set-SPOUser -Site "UrlDelSitioPersonal" -LoginName "CuentaAdmin" -IsSiteCollectionAdmin $true

Siendo "UrlDelSitioPersonal" la URL del sitio al que deseamos acceder y "CuentaAdmin", la cuenta a la que le delegaremos acceso como administrador.

Luego, desde nuestro navegador, accedemos al sitio personal, con las credenciales que delegamos acceso y allí podremos ver los archivos del sitio y poder descargarlos. Recordar que solamente disponemos de hasta 30 días después de la eliminación del usuario para acceder al sitio, por lo que se debe descargar la información antes de los 30 días.

Com este script, você consegue pesquisar qualquer objeto associado a um domínio especifico através de uma interface amigável.

Aqui fica uma amostra da interface:

NOTA: Por padrão, o script tentará se conectar ao Azure enquanto instala/importa os módulos necessários.
Este processo pode ser ignorado comentando (#) a seção "Conexões".

#------------------------------------------------------------------------------

# THIS CODE AND ANY ASSOCIATED INFORMATION ARE PROVIDED “AS IS” WITHOUT
# WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT
# LIMITED TO THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS
# FOR A PARTICULAR PURPOSE. THE ENTIRE RISK OF USE, INABILITY TO USE, OR
# RESULTS FROM THE USE OF THIS CODE REMAINS WITH THE USER.

#------------------------------------------------------------------------------
#
# PowerShell Source Code
#
# NAME: Domain Association Search.PS1
#
# VERSION: 1.0
#
#------------------------------------------------------------------------------

#----------------------------------------------
#region Import Assemblies
#----------------------------------------------
[void][Reflection.Assembly]::Load('System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089')
[void][Reflection.Assembly]::Load('System.Data, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089')
[void][Reflection.Assembly]::Load('System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a')
[void][Reflection.Assembly]::Load('System.DirectoryServices, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a')
#endregion Import Assemblies

#Define a Param block to use custom parameters in the project
#Param ($CustomParameter)

function Main {

Param ([String]$Commandline)

if((Show-MainForm_psf) -eq 'OK')
{

}

$script:ExitCode = 0 #Set the exit code for the Packager
}

function Show-MainForm_psf
{

#----------------------------------------------
#region Import the Assemblies
#----------------------------------------------
[void][reflection.assembly]::Load('System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089')
[void][reflection.assembly]::Load('System.Data, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089')
[void][reflection.assembly]::Load('System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a')
#endregion Import Assemblies

#----------------------------------------------
#region Generated Form Objects
#----------------------------------------------
[System.Windows.Forms.Application]::EnableVisualStyles()
$form1 = New-Object 'System.Windows.Forms.Form'
$textbox1 = New-Object 'System.Windows.Forms.TextBox'
$listbox3 = New-Object 'System.Windows.Forms.ListBox'
$listbox2 = New-Object 'System.Windows.Forms.ListBox'
$listbox1 = New-Object 'System.Windows.Forms.ListBox'
$labelAZUREApps = New-Object 'System.Windows.Forms.Label'
$labelEXOMailboxesMailUser = New-Object 'System.Windows.Forms.Label'
$labelMSODSUsersGroupsCont = New-Object 'System.Windows.Forms.Label'
$labelDomainAssociationSea = New-Object 'System.Windows.Forms.Label'
$labelDomainName = New-Object 'System.Windows.Forms.Label'
$buttonSearch = New-Object 'System.Windows.Forms.Button'
$InitialFormWindowState = New-Object 'System.Windows.Forms.FormWindowState'
#endregion Generated Form Objects

$form1_Load = {
#Connections
$Module = Get-Module

$ModTMP="| "
foreach ($Mod in $Module){$ModTMP += $Mod.Name +" | "}

if($ModTMP.IndexOf("| MSOnline |") -gt -1) {
Import-Module Msonline
Write-Host "------------- Import MSOnline -------------" -fore cyan
}
else {
Install-Module msonline -Force
Import-Module Msonline
Write-Host "------------- Install MSOnline -------------" -fore cyan
}

if($ModTMP.IndexOf("| AzureAD |") -gt -1) {
Import-Module azuread
Write-Host "------------- Import AzureAD -------------" -fore cyan

}
else {
Install-Module azuread -Force
Import-Module azuread
Write-Host "------------- Install AzureAD -------------" -fore cyan
}

$livecred = Get-Credential
Connect-MsolService -Credential $livecred
$Session = New-PSSession -ConfigurationName Microsoft.Exchange -ConnectionUri https://outlook.office365.com/powerShell-liveID?serializationLevel=Full -Credential $LiveCred -Authentication Basic –AllowRedirection
Import-PSSession $Session -AllowClobber
Connect-AzureAD -Credential $livecred
}

$labelDomainAssociationSea_Click={

}

$labelDomainName_Click={

}

$textbox1_TextChanged={

}

$buttonSearch_Click = {
#Clear the Boxes
$listbox1.Items.Clear()
$listbox2.Items.Clear()
$listbox3.Items.Clear()

$form1.Cursor = 'WaitCursor'

#Run MSODS
$listbox1.Items.Add("Finding active Users...")
$msods = Get-Msoluser -all | Where-Object { $_.UserPrincipalName -match $textbox1.text }
$msods2 = Get-MsolUser -all | Where-Object { $_.ProxyAddresses -match $textbox1.text }
$msods3 = Get-MsolUser -all | Where-Object { $_.WindowsLiveId -match $textbox1.text }
if ($msods -ne $null) { $listbox1.Items.AddRange($msods.Displayname) }
if ($msods2 -ne $null) { $listbox1.Items.AddRange($msods2.Displayname) }
if ($msods3 -ne $null) { $listbox1.Items.AddRange($msods3.Displayname) }

$listbox1.Items.Add("Finding deleted Users...")
$msods6 = Get-Msoluser -returndeletedusers -all | Where-Object { $_.UserPrincipalName -match $textbox1.text }
$msods8 = Get-MsolUser -returndeletedusers -all | Where-Object { $_.ProxyAddresses -match $textbox1.text }
$msods9 = Get-MsolUser -returndeletedusers -all | Where-Object { $_.WindowsLiveId -match $textbox1.text }
if ($msods6 -ne $null) { $listbox1.Items.AddRange($msods6.Displayname) }
if ($msods8 -ne $null) { $listbox1.Items.AddRange($msods8.Displayname) }
if ($msods9 -ne $null) { $listbox1.Items.AddRange($msods9.Displayname) }

$listbox1.Items.Add("Finding Groups...")
$msods11 = Get-MsolGroup -all | Where-Object { $_.EmailAddresses -match $textbox1.text }
if ($msods11 -ne $null) { $listbox1.Items.AddRange($msods11.Displayname) }

$listbox1.Items.Add("Finding Contacts...")
$msods4 = Get-MsolContact -all | Where-Object { $_.UserPrincipalName -match $textbox1.text }
if ($msods4 -ne $null) { $listbox1.Items.AddRange($msods4.Displayname) }

#Run EXO
$listbox2.Items.Add("Finding MAilboxes...")
$exo15 = Get-Mailbox -ResultSize unlimited | Where-Object { $_.EmailAddresses -match $textbox1.text }
$exo17 = Get-Mailbox -Softdeleted -ResultSize unlimited | Where-Object { $_.EmailAddresses -match $textbox1.text }
$exo19 = Get-Mailbox -InactiveMailboxOnly -ResultSize unlimited | Where-Object { $_.EmailAddresses -match $textbox1.text }
$exo25 = Get-Sitemailbox -ResultSize unlimited | Where-Object { $_.EmailAddresses -match $textbox1.text }
if ($exo15 -ne $null) { $listbox2.Items.AddRange($exo15.Displayname) }
if ($exo17 -ne $null) { $listbox2.Items.AddRange($exo17.Displayname) }
if ($exo19 -ne $null) { $listbox2.Items.AddRange($exo19.Displayname) }
if ($exo25 -ne $null) { $listbox2.Items.AddRange($exo25.Displayname) }

$listbox2.Items.Add("Finding Mail Users...")
$exo11 = Get-MailUser -ResultSize unlimited | Where-Object { $_.EmailAddresses -match $textbox1.text }
if ($exo11 -ne $null) { $listbox2.Items.AddRange($exo11.Displayname) }

$listbox2.Items.Add("Finding Groups...")
$exo1 = Get-DistributionGroup -ResultSize unlimited | Where-Object { $_.EmailAddresses -match $textbox1.text }
$exo3 = Get-DynamicDistributionGroup -ResultSize unlimited | Where-Object { $_.EmailAddresses -match $textbox1.text }
$exo5 = Get-UnifiedGroup -ResultSize unlimited | Where-Object { $_.EmailAddresses -match $textbox1.text }
if ($exo1 -ne $null) { $listbox2.Items.AddRange($exo1.Displayname) }
if ($exo3 -ne $null) { $listbox2.Items.AddRange($exo3.Displayname) }
if ($exo5 -ne $null) { $listbox2.Items.AddRange($exo5.Displayname) }

$listbox2.Items.Add("Finding Groups...")
$exo9 = Get-MailContact -ResultSize unlimited | Where-Object { $_.EmailAddresses -match $textbox1.text }
if ($exo9 -ne $null) { $listbox2.Items.AddRange($exo9.Displayname) }

$listbox2.Items.Add("Finding Public Folders...")
$exo21 = Get-Mailbox -PublicFolder -ResultSize unlimited | Where-Object { $_.EmailAddresses -match $textbox1.text }
$exo23 = Get-MailPublicFolder -ResultSize unlimited | Where-Object { $_.EmailAddresses -match $textbox1.text }
if ($exo21 -ne $null) { $listbox2.Items.AddRange($exo21.Displayname) }
if ($exo23 -ne $null) { $listbox2.Items.AddRange($exo23.Displayname) }

#Run Azure
$listbox3.Items.Add("Finding Applications...")
$azure = Get-AzureADApplication | Where-Object { $_.IdentifierUris -match $textbox1.text }
if ($azure -ne $null) { $listbox3.Items.AddRange($azure.Displayname) }

$form1.Cursor = 'Default'

}

#region Control Helper Functions
function Update-ListBox
{

param
(
[Parameter(Mandatory = $true)]
[ValidateNotNull()]
[System.Windows.Forms.ListBox]
$ListBox,
[Parameter(Mandatory = $true)]
[ValidateNotNull()]
$Items,
[Parameter(Mandatory = $false)]
[string]
$DisplayMember,
[switch]
$Append
)

if (-not $Append)
{
$listBox.Items.Clear()
}

if ($Items -is [System.Windows.Forms.ListBox+ObjectCollection] -or $Items -is [System.Collections.ICollection])
{
$listBox.Items.AddRange($Items)
}
elseif ($Items -is [System.Collections.IEnumerable])
{
$listBox.BeginUpdate()
foreach ($obj in $Items)
{
$listBox.Items.Add($obj)
}
$listBox.EndUpdate()
}
else
{
$listBox.Items.Add($Items)
}

$listBox.DisplayMember = $DisplayMember
}
#endregion

$form1_FormClosing=[System.Windows.Forms.FormClosingEventHandler]{
#Event Argument: $_ = [System.Windows.Forms.FormClosingEventArgs

}

#----------------------------------------------
#region Generated Events
#----------------------------------------------

$Form_StateCorrection_Load=
{
#Correct the initial state of the form to prevent the .Net maximized form issue
$form1.WindowState = $InitialFormWindowState
}

$Form_StoreValues_Closing=
{
#Store the control values
$script:MainForm_textbox1 = $textbox1.Text
$script:MainForm_listbox3 = $listbox3.SelectedItems
$script:MainForm_listbox2 = $listbox2.SelectedItems
$script:MainForm_listbox1 = $listbox1.SelectedItems
}

$Form_Cleanup_FormClosed=
{
#Remove all event handlers from the controls
try
{
$textbox1.remove_TextChanged($textbox1_TextChanged)
$labelDomainAssociationSea.remove_Click($labelDomainAssociationSea_Click)
$labelDomainName.remove_Click($labelDomainName_Click)
$buttonSearch.remove_Click($buttonSearch_Click)
$form1.remove_FormClosing($form1_FormClosing)
$form1.remove_Load($form1_Load)
$form1.remove_Load($Form_StateCorrection_Load)
$form1.remove_Closing($Form_StoreValues_Closing)
$form1.remove_FormClosed($Form_Cleanup_FormClosed)
}
catch { Out-Null <# Prevent PSScriptAnalyzer warning #> }
}
#endregion Generated Events

#----------------------------------------------
#region Generated Form Code
#----------------------------------------------
$form1.SuspendLayout()
#
# form1
#
$form1.Controls.Add($textbox1)
$form1.Controls.Add($listbox3)
$form1.Controls.Add($listbox2)
$form1.Controls.Add($listbox1)
$form1.Controls.Add($labelAZUREApps)
$form1.Controls.Add($labelEXOMailboxesMailUser)
$form1.Controls.Add($labelMSODSUsersGroupsCont)
$form1.Controls.Add($labelDomainAssociationSea)
$form1.Controls.Add($labelDomainName)
$form1.Controls.Add($buttonSearch)
$form1.AutoScaleDimensions = '11, 20'
$form1.AutoScaleMode = 'Font'
$form1.ClientSize = '1075, 549'
$form1.Font = 'Microsoft Sans Serif, 10.2pt, style=Bold'
$form1.Margin = '6, 5, 6, 5'
$form1.Name = 'form1'
$form1.Text = 'Form'
$form1.add_FormClosing($form1_FormClosing)
$form1.add_Load($form1_Load)
#
# textbox1
#
$textbox1.Font = 'Microsoft Sans Serif, 10.2pt'
$textbox1.Location = '349, 81'
$textbox1.Margin = '6, 5, 6, 5'
$textbox1.Name = 'textbox1'
$textbox1.Size = '358, 27'
$textbox1.TabIndex = 13
$textbox1.add_TextChanged($textbox1_TextChanged)
#
# listbox3
#
$listbox3.Font = 'Microsoft Sans Serif, 10.2pt'
$listbox3.FormattingEnabled = $True
$listbox3.ItemHeight = 20
$listbox3.Location = '720, 254'
$listbox3.Margin = '6, 5, 6, 5'
$listbox3.Name = 'listbox3'
$listbox3.Size = '312, 264'
$listbox3.TabIndex = 12
#
# listbox2
#
$listbox2.Font = 'Microsoft Sans Serif, 10.2pt'
$listbox2.FormattingEnabled = $True
$listbox2.ItemHeight = 20
$listbox2.Location = '381, 254'
$listbox2.Margin = '6, 5, 6, 5'
$listbox2.Name = 'listbox2'
$listbox2.Size = '300, 264'
$listbox2.TabIndex = 11
#
# listbox1
#
$listbox1.Font = 'Microsoft Sans Serif, 10.2pt'
$listbox1.FormattingEnabled = $True
$listbox1.ItemHeight = 20
$listbox1.Location = '33, 254'
$listbox1.Margin = '6, 5, 6, 5'
$listbox1.Name = 'listbox1'
$listbox1.Size = '303, 264'
$listbox1.TabIndex = 10
#
# labelAZUREApps
#
$labelAZUREApps.AutoSize = $True
$labelAZUREApps.Font = 'Microsoft Sans Serif, 7.8pt, style=Bold'
$labelAZUREApps.Location = '730, 206'
$labelAZUREApps.Margin = '6, 0, 6, 0'
$labelAZUREApps.Name = 'labelAZUREApps'
$labelAZUREApps.Size = '58, 32'
$labelAZUREApps.TabIndex = 9
$labelAZUREApps.Text = 'AZURE
(Apps)'
#
# labelEXOMailboxesMailUser
#
$labelEXOMailboxesMailUser.AutoSize = $True
$labelEXOMailboxesMailUser.Font = 'Microsoft Sans Serif, 7.8pt, style=Bold'
$labelEXOMailboxesMailUser.Location = '382, 190'
$labelEXOMailboxesMailUser.Margin = '6, 0, 6, 0'
$labelEXOMailboxesMailUser.Name = 'labelEXOMailboxesMailUser'
$labelEXOMailboxesMailUser.Size = '227, 48'
$labelEXOMailboxesMailUser.TabIndex = 8
$labelEXOMailboxesMailUser.Text = 'EXO
(Mailboxes, MailUsers, Groups,
Public Folders)'
#
# labelMSODSUsersGroupsCont
#
$labelMSODSUsersGroupsCont.AutoSize = $True
$labelMSODSUsersGroupsCont.Font = 'Microsoft Sans Serif, 7.8pt, style=Bold'
$labelMSODSUsersGroupsCont.Location = '33, 206'
$labelMSODSUsersGroupsCont.Margin = '6, 0, 6, 0'
$labelMSODSUsersGroupsCont.Name = 'labelMSODSUsersGroupsCont'
$labelMSODSUsersGroupsCont.Size = '184, 32'
$labelMSODSUsersGroupsCont.TabIndex = 7
$labelMSODSUsersGroupsCont.Text = 'MSODS
(Users, Groups, Contacts)'
#
# labelDomainAssociationSea
#
$labelDomainAssociationSea.AutoSize = $True
$labelDomainAssociationSea.Font = 'Microsoft Sans Serif, 12pt, style=Bold'
$labelDomainAssociationSea.Location = '382, 9'
$labelDomainAssociationSea.Margin = '6, 0, 6, 0'
$labelDomainAssociationSea.Name = 'labelDomainAssociationSea'
$labelDomainAssociationSea.Size = '278, 25'
$labelDomainAssociationSea.TabIndex = 3
$labelDomainAssociationSea.Text = 'Domain Association Search'
$labelDomainAssociationSea.add_Click($labelDomainAssociationSea_Click)
#
# labelDomainName
#
$labelDomainName.AutoSize = $True
$labelDomainName.Location = '209, 84'
$labelDomainName.Margin = '6, 0, 6, 0'
$labelDomainName.Name = 'labelDomainName'
$labelDomainName.Size = '127, 20'
$labelDomainName.TabIndex = 2
$labelDomainName.Text = 'Domain Name'
$labelDomainName.add_Click($labelDomainName_Click)
#
# buttonSearch
#
$buttonSearch.Font = 'Microsoft Sans Serif, 7.8pt, style=Bold'
$buttonSearch.Location = '730, 78'
$buttonSearch.Margin = '6, 5, 6, 5'
$buttonSearch.Name = 'buttonSearch'
$buttonSearch.Size = '126, 35'
$buttonSearch.TabIndex = 1
$buttonSearch.Text = 'Search'
$buttonSearch.UseVisualStyleBackColor = $True
$buttonSearch.add_Click($buttonSearch_Click)
$form1.ResumeLayout()
#endregion Generated Form Code

#----------------------------------------------

#Save the initial state of the form
$InitialFormWindowState = $form1.WindowState
#Init the OnLoad event to correct the initial state of the form
$form1.add_Load($Form_StateCorrection_Load)
#Clean up the control events
$form1.add_FormClosed($Form_Cleanup_FormClosed)
#Store the control values when form is closing
$form1.add_Closing($Form_StoreValues_Closing)
#Show the Form
return $form1.ShowDialog()

}

#Start the application
Main ($CommandLine)

Hola! soy Eric Avila del grupo de Directory Services de LATAM.  Desde hace un tiempo he visto en nuestros clientes varias dudas sobre el proceso de migración de SHA1 a SHA2 en entidades certificadoras.
El proceso comenzó a despertar la necesidad de los clientes, a partir del anuncio de Microsoft sobre la falta de seguridad que presentaba el algoritmo SHA1 y el cual sería obsoleto para Enero, 2016.

By: Cesar Hara and Caio Cesar

O intuito deste artigo é auxiliar no entendimento geral do conceito por trás dos atributos “SourceAnchor” e “ImmutableID” em contas de usuários, utilizados em ambientes sincronizados via AD Connect.

Definição

SourceAnchor: um atributo imutável durante o tempo de vida de um objeto. Este atributo identifica um objeto sendo o mesmo no Active Directory On-Premises (Source of Authority) e no Azure AD. O sourceAnchor também é conhecido como ImmutableID.

Qual a diferença dos dois atributos? Nenhuma, além da nomenclatura. Os valores são idênticos – “sourceAnchor” geralmente é relacionado quando mencionamos o atributo na base de dados do AADConnect (metaverse), quando “ImmutableID” no Azure AD.

A palavra imutável significa não alterável, sendo assim o atributo deve ser escolhido com muito critério uma vez que o mesmo não pode ser alterado quando definido no Azure AD.

Pontos importantes

1. “Sourceanchor” e “ImmutableId” se referem ao mesmo atributo;
2. Este atributo é responsável por vincular um objeto do Active Directory local com o objeto que foi sincronizado/criado na nuvem (Azure AD);
3. Uma vez definido no Azure AD, o mesmo não pode ser alterado (se torna “Read Only” em contas sincronizadas).

ObjectGUID como sourceAnchor

Por padrão, até a versão de AD Connect 1.1.486.0, o atributo ObjectGUID era escolhido como o sourceAnchor no momento da instalação.

Isto significa que o Azure ADConnect criaria o valor de sourceAnchor (e respectivamente ImmutableId) fazendo uma conversão para base64 do atributo ObjectGUID dos objetos.

O ObjectGUID também é um atributo imutável, por esse motivo foi um bom candidato por muito tempo para ser o valor de ImmutableId das contas do Azure AD.

Podemos comprovar os valores exportando os dados das contas dos objetos. Neste exemplo, iremos utilizar uma conta de testes “user01@o365identity.com”:

ObjectGUID: 771a06cd-a5dc-4d9a-a5e2-6b6c6690326b

ImmutableID: zQYad9ylmk2l4mtsZpAyaw==

Conforme informado anteriormente, o valor de Sourceanchor/ImmutableID é uma conversão do valor de ObjectGuid.

Podemos utilizar os cmdlets nativos do módulo do Active Directory para descobrir o ImmutableID que deve ser definido no Azure AD*:

$guid = (get-Aduser sAmAccountname).ObjectGuid
$immutableID = [System.Convert]::ToBase64String($guid.tobytearray())
$immutableID

Após a sincronização da conta, confirmamos o valor no Azure AD:

Como podemos observar, a conta está corretamente vinculada, ou seja, o valor de ObjectGUID do objeto local convertido para base64 é exatamente o mesmo valor do objeto da nuvem.

Impacto na escolha do sourceAnchor

Vamos supor um cenário onde o atributo “displayName” foi escolhido como sourceAnchor no setup do AD Connect. Após a sincronização inicial, o ImmutableID na nuvem ficaria com o valor “User01”**.

Após um período de tempo, há a necessidade de alterar o displayName para “User”. Se este valor for alterado, na próxima tarefa de sincronização o AD Connect tentará alterar o ImmutableID de “User01” para “User”.

A consequência será um erro de duplicidade de atributos, pelo fato de que para o AD Connect e Azure AD, agora estamos lidando com duas contas diferentes - com diferentes valores de ImmutableID (a primeira “User01” e a segunda “User”).

Ou seja, uma vez definido o ImmutableID no AAD o mesmo se torna “Read-Only” sem a possibilidade de alteração. Isto significa o valor de sourceAnchor, deve ser sempre imutável.

Conclusão

O ImmutableID é muito importante e deve ser compreendido para evitar problemas futuros.

Se não houver um bom planejamento do ambiente sincronizado, problemas complexos surgirão.

* Algumas pessoas optam pela utilização do ps1 “GUID2ImmutableID”. O resultado final é o mesmo.

** Se o sourceAnchor selecionado não for do tipo de cadeia de caracteres, o Azure AD Connect usará Base64Encode no valor do atributo para assegurar que nenhum caractere especial será exibido.If you use another federation server than ADFS, make sure your server can also Base64Encode the attribute.

Hello everyone, we decided to write this article since the number of customers using certificate authentication is increasing, together with the number of cases.

This is one of the most common and problematic scenarios we are facing nowadays - and the reason why we are covering it today.

Scenario:

Hey Microsoft Support, we have configured all settings as the articles below state and this is not working, the user is never prompted for a certificate and the page just keeps loading:
https://blogs.msdn.microsoft.com/samueld/2016/07/19/adfs-certauth-aad-o365/

https://docs.microsoft.com/en-us/windows-server/identity/ad-fs/operations/configure-user-certificate-authentication

Troubleshooting:

The quick fix (for this scenario also applies for android devices not authenticating), open the Local Computer certificates MMC, on the “Trusted Root” container check if there is any non-root CA certificate misplaced there.

If there is any, just remove them and restart the server (yes restart the server to update this information).

Important: You must do this on all ADFS and WAP servers.

Another way to find a misplaced certificate is by running the following PowerShell cmdlet:

Get-Childitem cert:\LocalMachine\root -Recurse | Where-Object {$_.Issuer -ne $_.Subject} | Format-List * | Out-File "c:\computer_filtered.txt"

If there is any data on the output file, then you need to take action.

Moving forward with the analysis of the problem, what happens is:

When we are establishing an SSL communication for certificate authentication, the server will send the “Certificate Trust List” to the client so they can start the communication, this list is pretty much the information about all certificates placed in the “Trusted Root” container on the server.

Presenting this list to the client, the client can find a matching root certificate with one that it owns, to perform the cert based authentication.

If a non-root certificate is misplaced on the “Trusted Root” container, the server will not send the complete list, and the client will be unable to choose a personal certificate it has, that is trusted by the ADFS/WAP server.

We can see this behavior by taking a network trace on the client machine, we will use Wireshark here to make it simple:

1. After capturing the trace, we need to configure Wireshark to show us the frames properly.First, locate a frame where the port 49443 (in ADFS 2012 R2 we use this port for cert authentication) was captured:
   
   With this setting applied we are telling Wireshark to consider the traffic on port 49443 as an SSL (default 443) traffic.
2. On any frame, right-click and select “Decode As” and the following window will show, change column “Value” to 49443 and “Current” to SSL and click “Accept”:
   
3. The last thing we will have to do is to apply the filter to show only SSL Handshake and the IP of the ADFS server:ssl.handshake && ip.addr == 198.1.1.1
   

Consequently, we will have a much cleaner capture to analyze now, we can seek (in this case) the last “Server Hello” frame, in the “Certificate Request” section, we are only sending one certificate, instead of the whole list:

If we look at the same section, for a scenario that works, we are be able to see the whole list as we do have on the server:

Conclusion:

To wrap it up, the rule is to have all certificates in their respective containers, Root, Intermediate, Personal and so on... If we misplace them, we will find ourselves in the scenario above.

If this is not the problem, it could be an issue with certificate’s AIA and CDP verification - but we will discuss this further in another article!

By: Caio Ribeiro César e Ramon Rocha

Em 2011, comentamos sobre o procedimento para High Availability de Edge Transport Servers. Este procedimento consistia basicamente de um export de configurações para XML e posteriormente o import para os outros servidores.

O tempo passou, porém ainda utilizamos XML para diversas tarefas administrativas. Hoje, iremos comentar sobre a exportação e importação de ETR (Exchange Transport Rules).

Exportar a coleção de regras é um processo de duas etapas. Inicialmente, exportamos as de regras para uma variável e, em seguida, gravamos os dados em um arquivo XML.

No exemplo abaixo, exportamos as regras de um Exchange Online:

PS C:\Users\caioc> $file = Export-TransportRuleCollection
PS C:\Users\caioc> Set-Content -Path "C:\Users\caioc\Downloads\RulesExO.xml" -Value $file.Filedata -Encoding Byte

A regra é exportada em um arquivo XML:

ExO

 <?xml version="1.0" encoding="UTF-16" standalone="true"?>

<rules name="TransportVersioned"><rule name="Mailbox Almost Full" format="cmdlet" id="ea7affcb-dad7-4fed-b7a2-241b3a596111"><version requiredMinVersion="15.0.3.0"><commandBlock><![CDATA[

New-TransportRule -Name 'Mailbox Almost Full' -Mode Enforce -SubjectContainsWords 'Your mailbox is almost full' -CopyTo 'caioc@c4iocesar.onmicrosoft.com'

]]></commandBlock></version></rule>

No exemplo abaixo, exportamos as regras de um ambiente Exchange Server 2010 (legacy):

<rule name="Discard messages to - noreply@c4iocesar.com" comments="Noreply Disregard Emails"><version requiredMinVersion="14.0.0.0"><fork><recipient address="noreply@c4iocesar.com"/></fork><condition><and><true/></and></condition><action name="DeleteMessage"/></version></rule>

Como podemos visualizar, o padrão do formato do arquivo diferencia entre versões antigas e as mais atuais (2013+).

O processo para importar a regra segue o mesmo padrão - carregamos os dados para uma variável e depois usamos essa variável para transmitir os dados para o cmdlet:

PS C:\Users\caioc> [Byte[]]$Data = Get-Content -Path "C:\Users\caioc\Downloads\RulesExO.xml" -Encoding Byte -ReadCount 0
PS C:\Users\caioc> Import-TransportRuleCollection -FileData $Data
Confirm
Importing a rule collection will overwrite all existing rules in that collection.  Do you want to continue?
[Y] Yes  [A] Yes to All  [N] No  [L] No to All  [?] Help (default is "Y"): A
WARNING: The message rejection text and custom status code that you created are ignored because you have configured the policy to notify the sender with a Policy Tip. - Error details: RejectMessageReasonText and RejectMessageEnhancedStatusCode parameters will be ignored because  NotifySender action is set to NotifyOnly.
WARNING: The rule contains NotifySender action with an option that may reject the message. In case the message gets rejected, other actions won't be applied.

Conforme podemos observar acima, as regras foram importadas de um arquivo xml. É muito importante ressaltar que o import substitui todas as regras de transporte definidas na sua organização. Ou seja, ele irá sobrescrever as configurações de acordo com o arquivo XML.

Recentemente, a equipe de suporte teve um chamado em que ao importar as regras de um ambiente Exchange Server 2010 para o Exchange Online, o erro abaixo ocorria:

PS C:\Users\caioc> [Byte[]]$Data = Get-Content -Path "C:\Users\caioc\Downloads\Rules.xml" -Encoding Byte -ReadCount 0
PS C:\Users\caioc> Import-TransportRuleCollection -FileData $Data
Confirm
Importing a rule collection will overwrite all existing rules in that collection.  Do you want to continue?
[Y] Yes  [A] Yes to All  [N] No  [L] No to All  [?] Help (default is "Y"): A
'Import-TransportRuleCollection' cannot be used with a engine-based XML file in Datacenter environment.
    + CategoryInfo          : InvalidData: (File Data:String) [Import-TransportRuleCollection], ParseException
    + FullyQualifiedErrorId : [Server=FR1PR80MB1730,RequestId=8a6017a4-4ce7-44d2-bc92-a235d03861b3,TimeStamp=12/21/2017 4:50:05 PM] [
   FailureCategory=Cmdlet-ParseException] 5BFD5E30,Microsoft.Exchange.MessagingPolicies.Rules.Tasks.ImportTransportRuleCollection
    + PSComputerName        : ps.outlook.com

A mensagem de erro “Cannot be used with a engine-based XML file in Datacenter environment” ocorre pois o formato do conjunto de regras de transporte exportado foi alterado no Exchange Server 2013.

O novo formato não pode ser exportado da versão 2010 para o Exchange Online, ou mesmo importado das atuais para o Exchange Server 2010.

O workaround para este cenário é a importação destas regras para versões 2013 ou 2016 e então um novo export & import para o Exchange Online.

En nuestro día a día en el equipo de Soporte manejamos variados escenarios, cuando múltiples clientes y/o socios de negocios se encuentran con el mismo inconveniente o comportamiento es momento de explicar cómo fue diseñado el producto, cuál es su comportamiento esperado y como los administradores del mismo deben actuar.

En reiteradas ocasiones hemos visto casos relacionados con problemas de entrega a destinatarios externos al utilizar el dominio "@*.onmicrosoft.com". Cuando un usuario envía un correo con una dirección SMTP "usuario@tenant.onmicrosoft.com", estos mensajes son rechazados con el siguiente mensaje.

5. a) “Remote Server returned ‘550 5.7.501 Access denied, spam abuse detected”;
6. b) The organization admin will list those emails in the High Risk Delivery Pool (HRDP), classified as outbound spam;
7. c) Recipient mail server will reject the message, informing that it is classified as SPAM (usually with a high Spam Confidence Level;SCL).

Surge entonces la pregunta de ¿ por qué el mensaje se clasifica como SPAM ?.

El subdominio fue clasificado como SPAM por los mismos motivos que cualquier otro dominio seria (mails masivos, falsos positivos o usuarios que utilizan in dominio con propósitos de SPAM).

Cualquier remitente incluyendo el original [domain].onmicrosoft.com está sujeto a un proceso de analisis realizado por Exchange Online Protection (EOP) llamado "Outbound SPAM", pero no a controles adicionales.

Correo con destino a organizaciones externas deben ser enviados desde dominios validados como ser <@contoso.com> en lugar de <@contoso.onmicrosoft.com>. Si el correo utilizado es @contoso.com significa que el administrador ha provisto evidencia que le permiten demostrar que es el dueño de ese dominio (normalmente a través de la creación de un registro en DNS) y los buzones que se crean con esa dirección SMTP cumplen con la misma condición.

A pesar de que es técnicamente posible utilizar esta dirección (dominio.onmicrosoft.com) para enviar correos, no significa que sea una buena práctica o este recomendado hacerlo. Para corregir el problema, no use la dirección <@contoso.onmicrosoft.com>, utilice la de su dominio validado <@contoso.com>

Si usted recibe el mensaje de NDR a pesar de estar utilizando la dirección validada <@contoso.com>, entonces por favor abra un incidente con Soporte y con gusto lo asistiremos.

By: Caio Ribeiro César

Uma das opções para migrar mailboxes para o Exchange Online é a migração IMAP. Estes cenários ocorrem quando o servidor de origem é executado em plataformas de terceiros como gmail, dovecot, entre outros produtos. O IMAP pode até ser habilitado em um servidor On-Premises (Exchange), porém, como existem outros métodos de migração para este source, não é um cenário comum.

Para que uma migração IMAP funcione, o servidor source deve ser acessado pelo Exchange Online via portas 143 ou 993 (ssl).

Considerações migrações IMAP:

• A migração IMAP não é completa. Itens de calendário, contatos, regras e tarefas não são migrados;
• O protocolo IMAP não efetua o provisionamento de usuários. Isto deve ser feito pelo administrador com um arquivo csv;
• Em alguns cenários, o servidor de origem não suporta o adicionar permissões em mailboxes (algo parecido com o Full Mailbox Permission). Isto significa que o arquivo .csv pode precisar armazenar as senhas de cada mailbox;
• Alguns servidores IMAP utilizam modelos diferentes de autenticação. Isto significa que o arquivo csv pode utilizar modelos de template diferentes do padrão.

Migração IMAP em etapas:

1. Provisionamento de usuários;
2. Criação do CSV com as credenciais de cada mailbox ou utilizando permissão de administrador em cada conta;
3. Criação do Endpoint de migração (recomendação utilização da porta 993 com SSL) ;
4. Sincronismo Inicial;
5. Sincronismo Incremental a cada 24 horas;
6. Validamos se as mailboxes e dados foram migrados para o destino (Exchange Online, Get-MailboxFolderStatistics);
7. Alteração do MX para o Exchange Online;
8. Confirmamos que o mailflow está funcionando (emails sendo entregues para as mailboxes no Exchange Online), selecionamos a opção de completar a migração no batch;
9. O “delta” de dados é feito pelo último Sincronismo Incremental e a migração termina.

Considerações de Troubleshooting em IMAP:

Networking – telnet nas portas 143/993 (dentro, fora da rede);

Utilizar o próprio Outlook para conectar na mailbox que está sendo migrada (opção de IMAP);

Problemas com o arquivo csv – validar EmailAddress, UserName, Password e os modelos em cada servidor (com ou sem impersonate do administrador);

PowerShell - Get-Migrationbatch, Get-MigrationUser , Get-MigrationStatus (| fl);

Caso não tenha o Outlook, o teste de conexão e listagem de pastas pode ser efetuado via telnet na 143:

		Telnet IMAP.empresa.com.br 143 
		? LOGIN DOMAIN/UserAlias PASSWORD 
		? LIST "" "*" 
		? Select Sent 
		? LIST "" "*"

*Exemplo de listagem da pasta “Sent”.

Vamos então ao cenário.

Cliente migrando de uma plataforma IMAP (servidor dovecot) para o Exchange Online. No momento da criação do batch, temos o erro abaixo:

“The username or password for this account is incorrect, or IMAP access is disabled. --> The username or password for this account is incorrect, or IMAP access is disabled. --> Imap server reported an error during LoginCommand indicating that authentication failed: 'Authentication failed.'.”

Test-MigrationServerAvailability -IMAP -RemoteServer  -Port <143 or 993> -Security <None, Ssl, or Tls>

Após esta etapa, acessamos no Outlook uma das mailboxes que estava sendo migrada (com sucesso). Confirmamos e o template de csv estava corretamente configurado para o servidor de origem (dovecot).

Passamos para a segunda etapa de troubleshooting, coletando o Relatório simples da migração. No log, conseguimos listar o erro “FolderHierarchyContainsMultipleRootsTransientException”:

19/02/2018 11:05:51 [FR1PR80MB1554] '' created request.
19/02/2018 11:06:16 [FR1PR80MB1809] The Microsoft Exchange Mailbox Replication service 'FR1PR80MB1809.lamprd80.prod.outlook.com' (15.20.506.23 ServerCaps:7FFFFF, ProxyCaps:01FDC7FD6FFFBF5FFFFFCB07FFFF, MailboxCaps:, legacyCaps:7FFFFF) is examining the request.
19/02/2018 11:06:16 [FR1PR80MB1809] Connected to target mailbox 'c4iocesar.omicrosoft.com\asdasd-a-4e90-a384-3ba03b50f6ea (Primary)', database 'LAMPR80DG114-db001', Mailbox server 'FR1PR80MB1809.lamprd80.prod.outlook.com' Version 15.20 (Build 506.0).
19/02/2018 11:06:16 [FR1PR80MB1809] Sync state for request c4d602d9-58ca-4d75-7765-9db823000cc1 is null.
19/02/2018 11:06:18 [FR1PR80MB1809] Connected to source mailbox 'caioc@c4iocesar.com (IMAP)', database '', Mailbox server 'mail.c4iocesar.com:993 (None)' Version 0.0 (Build 0.0), proxy server 'FR1PR80MB1809.lamprd80.prod.outlook.com' 15.20.506.23 ServerCaps:7FFFFF, ProxyCaps:01FDC7FD6FFFBF5FFFFFCB07FFFF, MailboxCaps:, legacyCaps:01FDC7FD6FFFBF5FFFFFCB07FFFF.
19/02/2018 11:06:18 [FR1PR80MB1809] Request processing started.
19/02/2018 11:06:20 [FR1PR80MB1809] Transient error FolderHierarchyContainsMultipleRootsTransientException has occurred. The system will retry (1/600).
19/02/2018 11:11:26 [FR1PR80MB1809] The Microsoft Exchange Mailbox Replication service 'FR1PR80MB1809.lamprd80.prod.outlook.com' (15.20.506.23 ServerCaps:7FFFFF, ProxyCaps:01FDC7FD6FFFBF5FFFFFCB07FFFF, MailboxCaps:, legacyCaps:7FFFFF) is examining the request.
19/02/2018 11:11:26 [FR1PR80MB1809] Connected to target mailbox 'c4iocesar.omicrosoft.com\asdasd-50f2-4e90-a384-3ba03b50f6ea (Primary)', database 'LAMPR80DG114-db001', Mailbox server 'FR1PR80MB1809.lamprd80.prod.outlook.com' Version 15.20 (Build 506.0).
19/02/2018 11:11:26 [FR1PR80MB1809] Sync state for request c4d602d9-58ca-4d75-7765-9db823000cc1 is null.
19/02/2018 11:11:28 [FR1PR80MB1809] Connected to source mailbox 'caioc@c4iocesar.com (IMAP)', database '', Mailbox server 'mail.c4iocesar.com:993 (None)' Version 0.0 (Build 0.0), proxy server 'FR1PR80MB1809.lamprd80.prod.outlook.com' 15.20.506.23 ServerCaps:7FFFFF, ProxyCaps:01FDC7FD6FFFBF5FFFFFCB07FFFF, MailboxCaps:, legacyCaps:01FDC7FD6FFFBF5FFFFFCB07FFFF.
19/02/2018 11:11:28 [FR1PR80MB1809] Request processing started.

Temos uma suposição de que o servidor IMAP de origem possui uma estrutura muito extensa de pastas “Root”. Esta exceção não trouxe maiores informações de quais possíveis pastas “Roots” adicionais o Exchange Online não estava conseguindo criar na hierarquia desta caixa de correio - seguimos então para a terceira etapa de coleta de dados:

Get-MigrationUserStatistics -Identity caioc@c4iocesar.com -IncludeReport | Export-Clixml log.xml

Tendo o arquivo .xml em mãos, prosseguimos com a filtragem de conteúdo para a análise e exportamos apenas os erros para um arquivo de log:

PS C:\Users\caioc> $stats = Import-CliXml  C:\Users\caioc\Downloads\log.xml
PS C:\Users\caioc> $stats.report.Failures > logReportFalha.txt

Tendo então o erro abaixo:

Timestamp         : 2/19/2018 11:06:20 AM
FailureType       : FolderHierarchyContainsMultipleRootsTransientException
FailureHash       : 60ea
FailureCode       : -2146233088
MapiLowLevelError : 0
FailureSide       : 
FailureSideInt    : 0
ExceptionTypes    : {Exchange, Transient, MRS, MRSTransient}
ExceptionTypesInt : {1, 2, 10, 11}
WorkItem          : AnalyzeFolderHierarchy
Message           : Mailbox folder hierarchy contains multiple roots: [Folder2: EntryID: [len=54, data=56                3D313B503D494D41503B46503D42333045423941303344303544413533313537324139364131383232423735343134373043374244], ParentID: [len=54,data=563D313B503D494D41503B46503D34344331393641431423545363630354243313036414645304339303936303436433044424635], Type: Generic, WKFType:None], [Painitec: EntryID: [len=54, data=563D313B503D494D41503B46503D3344353535433130453], ParentID: [len=54, data=563D313B503D494D41503B46503D34344331393641433241423545363630354243313036414645304339303936303436433044424635], Type: Generic, WKFType: None].

Confirmamos com um segundo filtro no arquivo .xml:

PS C:\Users\caioc> $stats.report.failures[-1]

Timestamp         : 2/19/2018 4:13:40 PM
FailureType       : TooManyTransientFailureRetriesPermanentException
FailureHash       : 60ea
FailureCode       : -2146233088
MapiLowLevelError : 0
FailureSide       :
FailureSideInt    : 0
ExceptionTypes    : {Exchange, MRS, MRSPermanent}
ExceptionTypesInt : {1, 10, 12}
WorkItem          : AnalyzeFolderHierarchy
Message           : The job encountered too many transient failures (61) and is quitting. The most common
failure is FolderHierarchyContainsMultipleRootsTransientException with the hit count 60.
--> Mailbox folder hierarchy contains multiple roots: [Folder2: EntryID: [len=54, dat
a=3043374244], ParentID: [len=54, data=563D313B503D494D41503B46503D343443313936414
33241423545363630354243313036414645304339303936303436433044424635], Type: Generic,
WKFType: None], [Painitec: EntryID: [len=54, data=563D313B503D494D41503B46503D334435353543
31304533453446333144354638313330333633393339384344333041434433363535], ParentID:[len=54,
data=563D313B503D494D41503B46503D3434433139364143324142354536363035424331303641464339303936303436433044424635], Type: Generic, WKFType: None].
MessageData       :
DataContext       :
DataContextData   :
StackTrace        :
InnerException    : FolderHierarchyContainsMultipleRootsTransientException: Mailbox folder hierarchy contains multiple roots: [Folder2: EntryID: [len=54, 
Generic, WKFType: None].
UnknownElements   :
UnknownAttributes :
XmlSchemaType     :

Após esta última análise, provavelmente é algo que precisa ser corrigido no lado do servidor IMAP de origem, pois ter diversas “root folders” (pastas raízes) não é algo permitido no Exchange. Conseguimos entender do arquivo de log que a pasta específica “Folder2” estava sendo considerada pelo Exchange Online como uma pasta de sistema.

Removemos a pasta nas configurações de conta IMAP e a migração foi efetuada com sucesso.

Si deseamos crear listas de direcciones "AddressList" que contengan usuarios especificos podemos hacerlo utilizando el cmdlet New-AddressList y aplicando el filtro para que la misma contenga los usuarios deseados como se muestra a continuacion:

En este ejemplo vamos a crear una lista de usuarios cuyo departamento sea IT:

1-) Validamos a traves de una consulta que los usuarios listados son los que deseamos aparezcan en la lista de direcciones.

2- Luego vamos a crear la lista de direcciones con dichos usuarios.

3- Actualizamos los usuarios utilizando el siguiente comando.
Update-Recipient janedoe

4- Validamos que ahora el Usuario se muestra como perteneciente a esa lista de direcciones "ITDepartment"

5- Si deseamos hacer el proceso de forma masiva podemos realizarlo a traves de la importacion de los usuarios utilizando in CSV.

a-) Exportamos la lista de usuarios utilizando el comando:

Get-Recipient -Filter {(Department -eq 'IT')} |Select Guid |Export-Csv c:\temp\list.csv -NoTypeInformation

b-) importamos el CSV a PowerShell.

$users = import-csv c:\temp\list.csv

c-) Actualizamos los usuarios de la siguiente manera:

5- Finalmente confirmamos que vemos al Usuario en la lista a traves de OWA

Agradecimiento especial a Agustin Gallegos quien amablemente facilitó la parte de scripting.