Contexte :

Le problème décrit ci-dessous a été rencontré dans le cadre de la mise en place d’un serveur WSUS sous Windows Server 2012 R2.

Problème rencontré :

Suite à la mise en place de WSUS, toutes les installations de mises jours depuis les serveurs étaient en échec ainsi que la remontée des rapports.

Un code d’erreur apparait : 80244016.

Analyse :

Pour obtenir plus de détails sur ce type de problème, l’outil WireShark peut être utilisé depuis un « client » WSUS afin d’analyser les flux réseau entre le client et le serveur WSUS.

Il faut ensuite filtrer les résultats obtenus sur les protocoles http et https.

La traceWireShark permet de mettre en évidence qu’une erreur de type « http/1.1 400 Bad Request » est déclenchée.

En observant en détail la requête http, on observe que le client WSUS tente de récupérer un fichier « .cab » sur le serveur WSUS avec le nom complet du serveur WSUS (FQDN).

La requête essai de communiquer avec l’host : hote.mondomaine.com.

Explication :

Le problème est dû à une incohérence entre la configuration du site IIS du serveur WSUS et l’URL positionnée sur les clients WSUS.

Les deux valeurs doivent être identiques (soit le nom NetBIOS du serveur WSUS, soit son FQDN).

Pour trouver le paramètre erroné il suffit de vérifier tous les endroits où l’URL est rentrée.

Le premier point à vérifier est la configuration de la stratégie de groupe positionnant l’URL WSUS sur le client.

Pour vérifier il suffit de lancer la commande « Rsop.msc » sur le client WSUS, puis d’aller dans le dossier « Windows Update » dans la section Configuration Ordinateur / Modèle d’administration / Composant Windows :

L’URL est positionnée dans le paramètre « Spécifier l’emplacement intranet du service de mise à jour Microsoft »

Il ne reste plus qu’à vérifier la configuration de IIS. Une fois la page de management est ouverte il faut se mettre sur le site « WSUS Administration ».

Puis aller dans le paramètre « Bindings »

Et d’éditer l’adresse http.

Dans notre exemple, la GPO demande au client d’utiliser le FQDN du serveur alors que le site IIS accepte uniquement les requêtes adressées au nom court.

Résolution :

Pour résoudre le problème, il suffit de modifier le « host name » du site Web IIS par le FQDN du serveur.

Suite au redémarrage de IIS, les clients WSUS peuvent appliquer les mises à jour avec succès.

On peut vérifier en relançant une capture de trames et on s’aperçoit bien que le serveur WSUS répond avec le code 200, ce qui signifie que la requête a été traitée avec succès.

INTRODUCTION

Orchestrator (SCO) est une solution d'automatisation de processus (Run Book Automation – RBA) pour l'orchestration. Un runbook contient plusieurs activités connectées sous forme d'un workflow. Pour bien définir le chemin d'un workflow, il faudra savoir récupérer le code retour d'une activité. Par défaut, le code retour d'une activité (Initialize Data) est définit comme dans l'exemple ci-dessous:

Pour afficher l'écran ci-dessus, double-cliquer sur le lien entre deux activités. On cochant la bonne case, nous pourrons définir le chemin du workflow en cas de "success","warning" ou "failed". Mais, cela devient plus compliqué si nous souhaitons récupérer un code retour d'une application ou d'un script PoSh. Dans l'exemple ci-dessous, nous allons récupérer le code retour d'un script PoSh lancé par Orchestrator. 

Exemple

Nous allons créer un runbook qui lancera un script PoSH avec deux codes retour possible  : 100 et 101. Les deux codes retour doivent emprunter deux chemins diférents. Le runbook resemble à:

L'activité "Run Program" lancera le script. L'activité "Return code" en PoSh récupérera le code retour et le mettra dans une variable qu'on traitera par la suite. Attention: dans l'exemple le script PoSh est lancé par un fichier .bat.

Le script powershell contient les codes suivants: 

$server = "127.0.0.1"
$ping = new-object System.Net.NetworkInformation.Ping
$ReponsePing = $ping.Send($server)


if ($ReponsePing.status –eq “Success”) 
{
     return 100
}
else 
{
     return 101
}

Le script .bat contient les codes suivants:

powershell .\ping.ps1

Paramétrage des activités

Dans l'activité "Run Program":

Sélectionner "Command execution" puis entrer le nom du serveur, le chemin du fichier .bat et le répertoire de travail. 

Après l'exécution de l'activité, le code retour (100 ou 101) sera publié dans une variable publiée automatiquement. Le nom de la variable est Pure Output et on constate bien à la fin le code retour 100. 

Nous allons récupérer ce code retour sans une autre variable qu'on nommera $pureOutput grâce à un script PoSh définit dans l'activité "Return code".

Assurez vous que la variable est bien publiée dans "Published Data". Grâce à cette variable nous pourrons définir correctement le chemin à prendre si le code retour est 100 ou 101. Pour le faire, double-cliquer sur le connecteur (link) et ajouter la variable "pureOutput" et son contenu.

Faire la même chose sur le connecteur (link) pour le code retour 101.

Introduction 

Les applications qui sont accessibles sur internet sont bien souvent installées dans un environnement de DMZ pour des raisons de sécurité. Des fois, ces applications nécessitent un envoi de mail sans pour autant passer directement par le serveur SMTP mais en faisant un rebond sur un relais SMTP (encore une fois pour des raisons de sécurité). Nous allons installer et configurer ce relais SMTP sous IIS.

Prérequis

• 2 serveurs Windows (2, pour du load-balancing)
• 1 VIP F5 avec les deux serveurs configurés dans le pool (Le F5 gère automatiquement le load-balancing)
• l'ip du serveur SMTP

Installation IIS ( A faire sur les deux serveurs)

Sélectionner « Web Server (IIS) » et cliquer sur « Next ».

Laisser les fontionalités par défaut et faire un "Next" pour démarrer l'installation de IIS.

Configuration du relais SMTP (A faire sur les deux serveurs)

1. Lancer « Internet Information Services 6.0 Manager » et faire un clic droit sur « SMTP Virtual Server #1» puis sélectionner « Properties ».

2. Dans l’onglet « Access », cliquer sur « Authentification » et sélectionner « Anonymous »

3. Dans l’onglet « Delivery » , cliquer sur « Outbound Security».

4. Cliquer sur « Advanced » et entrer le Fully-Qualified domain name (Nom du serveur IIS) et dans Smart host, entrer l’addresse du serveur SMTP.

La configuration du relais SMTP est terminé.

Autoriser une application à envoyer des e-mails sur le relais SMTP (A faire sur les deux serveurs)

Pour autoriser une application à envoyer des e-mail en anonyme, il faudra autoriser l'ip de serveur applicatif sur le relais SMTP IIS.

1. Aller dans l’onglet « Access » et cliquer sur « Relay ». Cliquer sur Add pour entrer l’IP du serveur qui doit envoyer de e-mail. 

Introduction

Afin de réaliser une action régulière et standart, deux solutions sont possible :

• Réaliser l’action manuellement,
• Développer un script qui s’en charge automatiquement.

Prérequis

• Powershell,
• 7zip,
• Créer une tâche planifiée

Script

Le script suivant permet d’automatiquement envoyer par FTP dans un fichier chiffré, ce script utilise principalement les variables suivantes :

• $days_to_send : L’age maximum des fichiers à envoyer
• $source_path : Repertoire contenant les fichier à envoyer
• $zipdirectory : Repertoire provisoire où seront compressé les fichiers
• $log_location : emplacement du fichier de log
• $sz : emplacement l’executable de 7zip
• $ftp : FTP cible
• $user : username utilisé pour se connecter au FTP
• $pass : password utiliser pour se connecter au FTP et pour chiffré le fichier ZIP
• $From : Adresse email qui emet les notifications par mail
• $To : Adresse email recevant les notifications par mail
• $SMTPServer : serveur SMTP utilisé pour les notifications par mail

#MAIN
function main
{
#Date Variables
$full_date = Get-Date
$custom_date = $full_date.ToString("yyyyMMdd")
$days_to_send = 4
$limit = $full_date.AddDays(-$days_to_send)

#Location Variables
$source_path = "E:\BACKUP\DATA\Database"
$zipdirectory = "G:\FTP_Folder\TEMP_ZIP"
$log_location = "G:\FTP_Folder\Logs"
$sz = ("C:\Program Files\7-Zip\7z.exe")

#FTP Variables
$ftp = "ftp://ftpr.domain.com/" 
$user = "FTP_Username" 
$pass = "FTP_Password"

#General variables
$LogFile
$compressed_folder
$folder_to_compress
$environment = "PROD"

#Mail Variables
$From = "Hatem.DJELASSI@piservices.com"
$To = "Hatem.DJELASSI@piservices.com"
$Cc = "Jean.DUPONT@piservices.com"
$Attachment
$Subject 
$Body
$SMTPServer = "smtp.domain.com"
$SMTPPort = "25"

Create-log-file -_log_location $log_location;

#Start Log
Append-log-file -_text "---------------------------------------------------------------"
Append-log-file -_text "START LOG @$full_date"

Create-Directory -_path $zipdirectory;
Copy-backups-older-than -_source_path $source_path -_destination_path $folder_to_compress -_limit $limit;
Compress_folder -_sz $sz -_pass $pass -_zipdirectory $zipdirectory -_folder_to_compress $folder_to_compress;
Delete_Folder -_file_to_delete $folder_to_compress;
Send_FTP -_user $user -_pass $pass -_ftp $ftp -_file_to_send $compressed_folder;
Notify -_from $From -_to $To -_cc $cc -_subject $Subject -_body $Body -_smtp $SMTPServer -_port $SMTPPort;

$compressed_folder = Get-ChildItem -Path $zipdirectory -Recurse -Force | Where-Object {$_.extension -match ".7z"} -ErrorAction stop
try
    {
        Remove-Item $compressed_folder.FullName -Recurse -ErrorAction Stop
        Append-log-file -_text "OK Deletion of the item has been made successfully" -_LogFile $LogFile;
    }
catch
    {
        Append-log-file -_text "ERROR when deleting the item $compressed_folder" -_LogFile $LogFile;
        write-host "An error occurred when deleting the item $compressed_folder" + $_.Exception.Message 
    }


#End log
Append-log-file -_text "END LOG @$full_date"
Append-log-file -_text "---------------------------------------------------------------"

}

#SendMail Function
function Notify
{
    param($_from, $_to, $_cc, $_attachment, $_subject, $_body, $_smtp, $_port)
    try 
            {           
                Send-MailMessage -From $_From -to $_To -Cc $_Cc -Subject $_Subject `
                -Body $_Body -SmtpServer $_SMTP -port $_Port 
                Append-log-file -_text "The email notification has been sent successfully" -_LogFile $LogFile;
            }
        catch
            {
                write-host "An error occurred when sending the notification" + $_.Exception.Message 
                Append-log-file -_text "The email notification has not been sent" -_LogFile $LogFile;
            }
}


#Log file functions
function Create-log-file 
{
    param ([string]$_log_location)        
    if (!(Test-Path "$_log_location\$custom_date - FTP_Script.log"))
    {
        try 
            {           
                $_LogFile = "$_log_location\$custom_date - FTP_Script.log"
                Set-Variable -Name LogFile -Value $_LogFile -Scope 1
            }
        catch
            {
                write-host "An error occurred when creating the log file" + $_.Exception.Message 
            }
        
    }
    else
    {
        try 
            {
                $_LogFile = "$log_location\$custom_date - FTP_Script.log"
                Set-Variable -Name LogFile -Value $_LogFile -Scope 1
            }
        catch
            {
                write-host "An error occurred when reusing the log file" + $_.Exception.Message 
            }
    }
}

function Append-log-file 
{
    param ($_text)
    try 
        {
            $custom_date+" "+$_text | Out-File $LogFile -Append -Force
        }
    catch
        {
            write-host "An error occurred when writing into the log file" + $_.Exception.Message 
        }
}

#Folders & files functions
function Create-Directory
{
    param ($_path)
    try 
        {
            $_folder_to_compress = New-Item -ItemType directory -Path "$_path\$custom_date - $environment Database Export" -force -ErrorAction Stop
            Set-Variable -Name folder_to_compress -Value $_folder_to_compress -Scope 1
            Append-log-file -_text "OK New folder to compress created successfully" -_LogFile $LogFile;

        }
    catch
        {
            Append-log-file -_text "ERROR when creating new folder to compress" -_LogFile $LogFile;
            write-host "An error occurred when creating new folder to compress" + $_.Exception.Message 
        }
}

function Copy-backups-older-than
{
    param ($_source_path, $_destination_path, $_limit)
    try
        {
            Get-ChildItem -Path $_source_path -Recurse -Force | Where-Object {$_.extension -in ".dif",".bak" -and !$_.PSIsContainer -and $_.CreationTime -gt $_limit } | copy-item -Destination  $_destination_path -Force -Container -ErrorAction stop
            Append-log-file -_text "OK The copy of the backups made after $limit has been made successfully" -_LogFile $LogFile;
        }
    catch
        {
            Append-log-file -_text "ERROR when copying the backups made after $limit" -_LogFile $LogFile;
            write-host "An error occurred when copying the backups made after $limit" + $_.Exception.Message 
        }
}

function Compress_folder
{
    param ($_sz, $_pass, $_zipdirectory, $_folder_to_compress)
    try
    {
        & $sz a -p"$_pass" "$_zipdirectory\$custom_date - $environment Database Export.7z" "$_folder_to_compress\*"
        $_compressed_folder = Get-ChildItem -Path $_zipdirectory -Recurse -Force | Where-Object {$_.extension -match ".7z"} -ErrorAction stop
        Set-Variable -Name compressed_folder -Value $_compressed_folder -Scope 1
        Append-log-file -_text "OK Compression/encryption of the folder has been made successfully" -_LogFile $LogFile;
    }
    catch
    {
        Append-log-file -_text "ERROR during compression/encryption of the folder" -_LogFile $LogFile;
        write-host "An error occurred during compression/encryption of the folder" + $_.Exception.Message 
    }
}

function Delete_Folder
{
    param ($_file_to_delete)
    try
    {
        Remove-Item "$_file_to_delete" -Recurse -ErrorAction stop
        Append-log-file -_text "OK Deletion of the item has been made successfully" -_LogFile $LogFile;
    }
    catch
    {
        Append-log-file -_text "ERROR when deleting the item $_file_to_delete" -_LogFile $LogFile;
        write-host "An error occurred when deleting the item $_file_to_delete" + $_.Exception.Message 
    }
}

#FTP Function
function Send_FTP
{
    param ($_user, $_pass, $_ftp, $_file_to_send, $_subject, $_body)
    #Create Web client
    try
    {
        $webclient = New-Object System.Net.WebClient -ErrorAction stop
        $webclient.Credentials = New-Object System.Net.NetworkCredential($_user,$_pass) -ErrorAction Stop 
        $webclient.Proxy = $NULL 
        Append-log-file -_text "OK FTP WebClient created successfully" -_LogFile $LogFile;
    }
    catch
    {
        Append-log-file -_text "ERROR when creating the FTP WebClient" -_LogFile $LogFile;
        write-host "An error occurred when creating the FTP WebClient" + $_.Exception.Message 
    }
    #Create URI
    try
    {
        $_uri = New-Object System.Uri($_ftp+$_file_to_send.Name) -ErrorAction stop 
        Append-log-file -_text "OK FTP URI created successfully" -_LogFile $LogFile;
    }
    catch
    {
        Append-log-file -_text "ERROR when creating the FTP URI" -_LogFile $LogFile;
        write-host "An error occurred when creating the FTP URI" + $_.Exception.Message 
    }
    #Send the file
    try
    {
        $webclient.UploadFile($_uri, $_file_to_send.FullName)
        Append-log-file -_text "OK FTP file sent successfully" -_LogFile $LogFile;
        $global:Subject = "FTP Upload Success"
        $global:Body = "The file $_file_to_send has been sent successfully @$full_date"
    }
    catch
    {
        Append-log-file -_text "ERROR when sending the file through FTP" -_LogFile $LogFile;
        write-host "An error occurred when sending the file through FTP" + $_.Exception.Message 
        $global:subject = "FTP Upload Failure"
        $global:Body = "An error occurred when sending the FTP backups from $environment to FTP @$full_date"
    }
}

main

Introduction

Afin de fournir à un utilisateur le droit d’executer une procédure stockée, un administrateur SQL peut fournir à un utilisateur le droit “EXECUTE” sur celle-ci.

Cependant, il est possible que l’utilisateur rencontre une erreur lors de l’execution de la procédure stockée de type :

Celà est souvent du à la présence de code SQL dynamique, généré lors de l’execution.

Explication

Il est possible de fournir à l’utilisateur le droit “SELECT” sur l’objet de la requête et le script pourras être executé avec succès, néanmoins, celà vas contre le principe d’une procédure stockée qui permet de fournir aux utilisateurs un accès aux données via l’interface restrictive de la procédure stockée.

Afin de résoudre ce problème il est possible (à partir de SQL 2008) d’utiliser la clause “EXECUTE AS” en spécifiant un compte disposant des droits nécessaires à l’execution de la procédure stockée.

Il est important de noter que l’utilisation de “EXECUTE AS” ne fournit pas à l’utilisateur final des droits d’impersonnalisation qui permetteraient à l’utilisateur de “récuperer” les droits du compte d’execution.

Réalisation

L’exemple suivant explique comment utiliser “EXECUTE AS” :

La ligne 2 spécifie le compte “SQLUser” à utiliser pour l’execution du script,

La ligne 5 retourneras le compte “SQLUser”,

La ligne 7 “EXECUTE AS CALLER” permet d’utiliser le compte de l’utilisateur executant la procédure stockée,

La ligne 8 retourneras le compte de l’utilisateur executant la procédure stockée,

La ligne 10 “REVERT” retablis l’utilisation du compte “SQLUser” spécifié au début du script.

Source

https://msdn.microsoft.com/fr-fr/library/ms181362.aspx

http://www.sqlmatters.com/Articles/Using%20Execute%20As%20with%20Stored%20Procedures%20Containing%20Dynamic%20SQL.aspx

Introduction

L’une des requêtes qui peut être demandé à un adminsitrateur SQL est l’execution régulière d’une requête et le transmission de son résultat par email.

Prérequis

Afin de répondre à ce type de demande, les outils suivants seront utiles :

• La procédure “sp_send_dbmail”,
• L’agent SQL Server,
• La configuration d’un profile Database Mail.

Réalisation

Le script suivant permet d’envoyer par mail le résultat de la procédure stockée “usp_StoredProcedure” :

Depuis la base MSDB, executer la procedure “sp_send_dbmail” (ligne 1), cette procédure prends les paramètres suivants :

@profile_name : profile mail configuré sur SQL Server sous le dossier “Management”

@recipients : adresse mail du destinataire

@subject : sujet qui figureras dans le mail envoyé

@query : requête à executer

@query_result_width : largeur en nombre de caractère du fichier qui seras envoyé en pièce jointe, par défaut la valeur est de 256 caractères, ce paramètre est important si l’on souhaite réaliser par la suite un import vers excel

@attach_query_result_as_file : utiliser la valeur “1” afin de fournir le resultat de cette requête dans un fichier en pièce jointe

@query_attachment_filename : nom du fichier en pièce jointe

@query_result_separator : caractère de séparation qui seras utilisé

L’article suivant explique plus en détails les paramètres qu’il est possible d’utiliser : https://msdn.microsoft.com/fr-fr/library/ms190307.aspx

Dans le cadre de la gestion des certificats dans Active Directory, il arrive que l’on retrouve des valeurs de ce type pour les attributs UserCertificate ou CaCertificate:

Ce type de champ est difficilement lisible et cela peut donc complexifier la tâche lorsque l’on veut supprimer un certificat déployé en doublon, ou tout simplement un certificat avec des informations erronées.

Pour rapidement différencier les certificats il suffit de suivre les étapes suivantes:

Copier le contenu Hexadécimal dans un fichier texte :

Exécuter la commande suivante :

Certutil –decodehex C:\Temp\HexValue.txt C:\Temp\OutputCert.cer

Le résultat de la commande est un fichier .cer que l’on peut ouvrir et qui contiendra les attributs du certificat de manière lisible, ces opérations doivent être répétées sur les différentes entrées pour chaque certificat à identifier.

Voici comment fixer le navigateur par défaut de vos utilisateurs.

Via PowerShell:

Exécutez les commandes suivantes à l'ouverture de session utilisateur sous forme de script powershell en fonction de votre choix.

Pour Internet Explorer:

Set-Location HKCU:\
    Set-ItemProperty 'HKCU:\Software\Microsoft\Windows\Shell\Associations\UrlAssociations\ftp\UserChoice' -name ProgId IE.FTP
    Set-ItemProperty 'HKCU:\Software\Microsoft\Windows\Shell\Associations\UrlAssociations\http\UserChoice' -name ProgId IE.HTTP
    Set-ItemProperty 'HKCU:\Software\Microsoft\Windows\Shell\Associations\UrlAssociations\https\UserChoice' -name ProgId IE.HTTPS

Pour Mozilla Firefox:

Set-Location HKCU:\
    Set-ItemProperty 'HKCU:\Software\Microsoft\Windows\Shell\Associations\UrlAssociations\ftp\UserChoice' -name ProgId FirefoxURL
    Set-ItemProperty 'HKCU:\Software\Microsoft\Windows\Shell\Associations\UrlAssociations\http\UserChoice' -name ProgId FirefoxURL
    Set-ItemProperty 'HKCU:\Software\Microsoft\Windows\Shell\Associations\UrlAssociations\https\UserChoice' -name ProgId FirefoxURL

Vous pouvez aussi le faire par GPO dans "Configuration Utilisateur > Paramètres Windows > Registre"

AppLocker est une fonctionnalité permettant de spécifier les utilisateurs ou groupes de votre organisation pouvant exécuter des applications particulières en fonction de l’identité unique des fichiers. Si vous utilisez AppLocker, vous pouvez créer des règles pour autoriser ou refuser l’exécution d’applications.

AppLocker peut, par exemple, être utilisé dans le cadre d’un déploiement d’une infrastructure PKI d’entreprise à deux niveaux afin de sécuriser l’autorité de certification racine.

Cependant, sur la version Windows Server 2016 et  il n’est actuellement pas possible de programmer le démarrage automatique du service AppIDSvc via l’interface graphique, ni même par GPO comme indiqué par Microsoft.

L’erreur suivante apparait quand on essaye d’appliquer le paramètre “Démarrage automatique” :

Afin que le service AppIDSvc se lance de manière automatique à chaque démarrage il faut modifier la clé de registre suivante:

Valeur: Start=2

Clé: HKLM\SYSTEM\CurrentControlSet\Services\AppIDSvc

Une fois la clé modifiée, redémarrez le service.

Le service est maintenant en démarrage automatique:

Il existe un type de migration possible connu sous le nom de « database-attach upgrade ». L'upgrade de SPS 2010 à 2013 n'étant pas supporté, il faut nécessairement créer une batterie de serveur SharePoint 2013. Nous supposons que la ferme SPS, du type 3 tiers est déjà créée.

La migration se déroule en trois grandes étapes :

• La préparation
• La mise à niveau des bases de données
• La mise à niveau des sites

Préparation

La première étape consiste à identifier les éléments que vous allez migrer. Par la même occasion, collectez l'ensemble des éléments relatifs à votre infrastructure SharePoint 2010 (configuration des webapp, Mappages des accès de substitution, Fournisseurs et modes d’authentification utilisés, Modèles de quota, Chemins d’accès gérés.... Nombres de sites, de BDD de contenu, d'utilisateurs...).

Il est recommandé de rechercher et réparer les erreurs de cohérence de données de données. Un lien technet explique comment nettoyer l’environnement SP 2010 avant une migration :

https://technet.microsoft.com/en-us/library/ff382641(v=office.15)

Une fois la configuration initiale terminée, créez les applications web pour chaque application web que vous aviez sur votre SPS 2010 sur la nouvelle plateforme SPS 2013.

La mise à niveau des bases de données

1. Passez en lecture seule les bases de données de SPS 2010 puis sauvegardez là. Pour le faire, dans « Options» de la base de données, sélectionnez « True » pour l’option « Database Read-Only ».

1. Restaurez les bases de données sur la nouvelle instance SQL de la ferme SPS 2013.
2. Quand une base de données est copiée, tous les anciens comptes de sécurité associés à la base de données sont conservés. Il faudra donc supprimer ces anciens comptes. Lors de son association avec SharePoint, les droits nécessaires lui seront automatiquement ajoutés (en l’occurrence les comptes Pool et Farm).

Mise à jour des bases de données

Avant d’associer les bases de données à leur WebApp respectives, il est nécessaire de s’assurer qu’elles ne présentent pas d’erreurs. Pour cela :

Test-SPContentDatabase -name "test1" -webapplication http://sitename -ServerInstance "SQL2"

Il se peut alors que les erreurs suivantes apparaissent :

1. Missing Feature
2. Missing Web Part
3. Missing Setup File
4. Missing Assembly

Ignorer l’erreur de configuration d’authentification suivante "Configuration: The [WebApp] web application is configured with claims authentication mode however […]."

Association des bases de données

Une fois les bases de données disponibles dans la nouvelle batterie, vous pouvez les lier et les mettre à niveau. Bien que cette opération mette à niveau les données, elle ne met pas à niveau l’interface utilisateur des sites contenus dans les bases de données. Mettez à niveau les bases de données à l’aide de la cmdlet Mount-SPContentDatabase.

Mount-SPContentDatabase "MyDatabase" -DatabaseServer "MyServer" -WebApplication http://sitename

Passage en authentification « claims »

Sous SharePoint 2013, l’authentification basique (NTLM) est « dégradée » et il convient d’utiliser l’authentification « claims ». Pour cela :

Convert-SPWebApplication -Identity "https://<webappurl>" -To Claims -RetainPermissions [-Force]

Notez que cela active les modes d’authentifications « Anonymous » et « Forms » dans IIS. De base, seules les authentifications Windows et ASP.NET sont activées.

Version des bases de données

Il est également recommandé de changer le mode de compatibilité des bases de données « Content ». Effectuez cette opération depuis Management Studio: Clic droit sur la base de données « Content » > Properties > Options

MISE À NIVEAU DES SITES

Une fois les bases de données mises à niveau, les administrateurs de collections de sites peuvent mettre à niveau leurs sites. Les étapes suivantes sont effectuées à partir de la page Paramètres du site de la collection de sites.

EXÉCUTION DES VÉRIFICATIONS D’INTÉGRITÉ DE COLLECTION DE SITES

Avant de mettre à niveau, les administrateurs de collections de sites peuvent utiliser l’outil de vérification d’intégrité pour identifier et traiter les problèmes éventuels qui surviennent dans leurs collections de sites. Les vérifications d’intégrité sont également exécutées automatiquement avant la mise à niveau.

MISE À NIVEAU D’UNE COLLECTION DE SITES

Après avoir vérifié que le site est prêt, les administrateurs de collections de sites peuvent mettre à niveau leur collection de sites vers la nouvelle interface utilisateur.

La migration est terminée.