Comment utiliser PowerShell pour automatiser les installations d’Office 365

Dans le monde rapide et exigeant de l’informatique, chaque outil permettant de gagner du temps et de simplifier les tâches est précieux. Nous allons explorer comment les scripts PowerShell peuvent être utilisés pour automatiser l’installation d’Office 365, une opération critique qui peut vous faire économiser d’innombrables heures à long terme. En fait, avec un script bien écrit, vous pouvez gérer les installations de tout un réseau depuis votre bureau. Cet article s’adresse aux professionnels de l’informatique et aux fournisseurs de services gérés (MSP) qui cherchent à optimiser leurs déploiements Office 365 en utilisant la puissance de PowerShell.

Pourquoi automatiser avec PowerShell ?

PowerShell est un langage de script avancé et un shell développé par Microsoft. Il fait partie intégrante de l’écosystème Windows depuis Windows 7, et sa puissance et sa flexibilité en ont fait un outil essentiel pour de nombreux professionnels de l’informatique et entreprises MSP. L’automatisation des installations d’Office 365 à l’aide de PowerShell peut réduire considérablement le temps et les efforts nécessaires au déploiement d’Office 365 sur plusieurs machines. 

De plus, les scripts PowerShell peuvent être personnalisés pour répondre à vos besoins. Par exemple, le script peut être configuré pour installer des composants Office 365 spécifiques, appliquer certains paramètres et même effectuer un nettoyage des données après l’installation. Ce niveau de personnalisation permet aux professionnels de l’informatique et aux entreprises MSP de s’assurer qu’Office 365 est déployé de manière cohérente sur toutes les machines, conformément aux stratégies et aux normes informatiques de l’entreprise. 

Exploration approfondie du script PowerShell d’installation d’Office 365

Examinons de plus près un exemple de script PowerShell pour automatiser les installations d’Office 365. Ce script est conçu pour installer Office 365 à l’aide d’un fichier de configuration personnalisé ou par défaut. En cas d’échec de l’installation, le script fournit un message d’erreur, ce qui facilite le dépannage.

Ce script est particulièrement utile car il permet de télécharger et d’utiliser l’outil de déploiement d’Office à partir des serveurs de Microsoft. Cette fonction garantit que la dernière version d’Office 365 est toujours utilisée pour l’installation. En outre, le script vérifie si la suite Office 365 a été installée correctement, ce qui constitue une garantie supplémentaire.

Une fois l’installation réussie, le script déclenche un redémarrage du système. Ceci est particulièrement pratique car certains composants d’Office 365 nécessitent un redémarrage du système pour fonctionner correctement. Le script est également équipé d’un mécanisme de nettoyage qui peut être activé pour supprimer les fichiers d’installation après l’installation d’Office 365.

Script PowerShell d’installation de Microsoft Office 365

#Requires -Version 5.1

<# .SYNOPSIS Installs Office 365 from a config file or creates a generic config file and installs. .DESCRIPTION Installs Office 365 from a config file or creates a generic config file and installs. .EXAMPLE No parameters need if you want to use the default config file OR change the $OfficeXML variable to use your XML config file's content. .EXAMPLE -ConfigurationXMLFile https://replace.me/configuration.xml Install Office 365 and use a local config file. You can use https://config.office.com/deploymentsettings to help build the config file. .OUTPUTS None .NOTES This will reboot after a successful install. Minimum OS Architecture Supported: Windows 10, Windows Server 2016 Release Notes: Renamed script and added Script Variable support, made restarts optional, changed default download path to %TEMP%\Office365Install, switched to downloading an xml instead of using a local path. #>

[CmdletBinding()]
param(
    # Use a existing config file
    [Parameter()]
    [String]$ConfigurationXMLFile,
    # Path where we will store our install files and our XML file
    [Parameter()]
    [String]$OfficeInstallDownloadPath = "$env:TEMP\Office365Install",
    [Parameter()]
    [Switch]$Restart = [System.Convert]::ToBoolean($env:restartComputer)
)

begin {
    if ($env:linkToConfigurationXml -and $env:linkToConfigurationXml -notlike "null") { $ConfigurationXMLFile = $env:linkToConfigurationXml }

    $CleanUpInstallFiles = $True

    # In case 'https://' is omitted from the URL.
    if ($ConfigurationXMLFile -and $ConfigurationXMLFile -notmatch "^http(s)?://") {
        Write-Warning "http(s):// is required to download the file. Adding https:// to your input...."
        $ConfigurationXMLFile = "https://$ConfigurationXMLFile"
        Write-Warning "New Url $ConfigurationXMLFile."
    }

    # Set TLS Version
    $SupportedTLSversions = [enum]::GetValues('Net.SecurityProtocolType')
    if ( ($SupportedTLSversions -contains 'Tls13') -and ($SupportedTLSversions -contains 'Tls12') ) {
        [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol::Tls13 -bor [System.Net.SecurityProtocolType]::Tls12
    }
    elseif ( $SupportedTLSversions -contains 'Tls12' ) {
        [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.SecurityProtocolType]::Tls12
    }
    else {
        # Not everything requires TLS 1.2, but we'll try anyway.
        Write-Warning "TLS 1.2 and or TLS 1.3 are not supported on this system. This script may fail!"
        if ($PSVersionTable.PSVersion.Major -lt 3) {
            Write-Warning "PowerShell 2 / .NET 2.0 doesn't support TLS 1.2."
        }
    }

    function Set-XMLFile {
        # XML data that will be used for the download/install
        # Example config below generated from https://config.office.com/
        # To use your own config, just replace  to  with your xml config file content.
        # Notes:
        #  "@ can not have any character after it
        #  @" can not have any spaces or character before it.
        $OfficeXML = [XML]@"

  
  
    
      
      
      
      
      
      
    
  
  
  
  
  
  
  
  
    
    
    
    
  
  
   
  

"@
        #Save the XML file
        $OfficeXML.Save("$OfficeInstallDownloadPath\OfficeInstall.xml")
      
    }
    function Get-ODTURL {
    
        [String]$MSWebPage = Invoke-RestMethod 'https://www.microsoft.com/en-us/download/confirmation.aspx?id=49117'
    
        $MSWebPage | ForEach-Object {
            if ($_ -match 'url=(https://.*officedeploymenttool.*\.exe)') {
                $matches[1]
            }
        }
    
    }
    function Test-IsElevated {
        $id = [System.Security.Principal.WindowsIdentity]::GetCurrent()
        $p = New-Object System.Security.Principal.WindowsPrincipal($id)
        if ($p.IsInRole([System.Security.Principal.WindowsBuiltInRole]::Administrator))
        { Write-Output $true }
        else
        { Write-Output $false }
    }

    # Utility function for downloading files.
    function Invoke-Download {
        param(
            [Parameter()]
            [String]$URL,
            [Parameter()]
            [String]$Path,
            [Parameter()]
            [int]$Attempts = 3,
            [Parameter()]
            [Switch]$SkipSleep
        )
        Write-Host "URL given, Downloading the file..."

        $i = 1
        While ($i -le $Attempts) {
            # Some cloud services have rate-limiting
            if (-not ($SkipSleep)) {
                $SleepTime = Get-Random -Minimum 3 -Maximum 15
                Write-Host "Waiting for $SleepTime seconds."
                Start-Sleep -Seconds $SleepTime
            }
        
            if ($i -ne 1) { Write-Host "" }
            Write-Host "Download Attempt $i"

            try {
                # Invoke-WebRequest is preferred because it supports links that redirect, e.g., https://t.ly
                if ($PSVersionTable.PSVersion.Major -lt 4) {
                    # Downloads the file
                    $WebClient = New-Object System.Net.WebClient
                    $WebClient.DownloadFile($URL, $Path)
                }
                else {
                    # Standard options
                    $WebRequestArgs = @{
                        Uri                = $URL
                        OutFile            = $Path
                        MaximumRedirection = 10
                        UseBasicParsing    = $true
                    }

                    # Downloads the file
                    Invoke-WebRequest @WebRequestArgs
                }

                $File = Test-Path -Path $Path -ErrorAction SilentlyContinue
            }
            catch {
                Write-Warning "An error has occurred while downloading!"
                Write-Warning $_.Exception.Message

                if (Test-Path -Path $Path -ErrorAction SilentlyContinue) {
                    Remove-Item $Path -Force -Confirm:$false -ErrorAction SilentlyContinue
                }

                $File = $False
            }

            if ($File) {
                $i = $Attempts
            }
            else {
                Write-Warning "File failed to download."
                Write-Host ""
            }

            $i++
        }

        if (-not (Test-Path $Path)) {
            Write-Error -Message "Failed to download file!" -Category InvalidResult -Exception (New-Object System.Deployment.Application.DeploymentDownloadException)
            exit 1
        }
    }

    # Check's the two Uninstall registry keys to see if the app is installed. Needs the name as it would appear in Control Panel.
    function Find-UninstallKey {
        [CmdletBinding()]
        param (
            [Parameter(ValueFromPipeline)]
            [String]$DisplayName,
            [Parameter()]
            [Switch]$UninstallString
        )
        process {
            $UninstallList = New-Object System.Collections.Generic.List[Object]

            $Result = Get-ChildItem HKLM:\Software\Wow6432Node\Microsoft\Windows\CurrentVersion\Uninstall\* | Get-ItemProperty | 
                Where-Object { $_.DisplayName -like "*$DisplayName*" }

            if ($Result) { $UninstallList.Add($Result) }

            $Result = Get-ChildItem HKLM:\Software\Microsoft\Windows\CurrentVersion\Uninstall\* | Get-ItemProperty | 
                Where-Object { $_.DisplayName -like "*$DisplayName*" }

            if ($Result) { $UninstallList.Add($Result) }

            # Programs don't always have an uninstall string listed here so to account for that I made this optional.
            if ($UninstallString) {
                # 64 Bit
                $UninstallList | Select-Object -ExpandProperty UninstallString -ErrorAction Ignore
            }
            else {
                $UninstallList
            }
        }
    }
}
process {
    $VerbosePreference = 'Continue'
    $ErrorActionPreference = 'Stop'

    if (-not (Test-IsElevated)) {
        Write-Error -Message "Access Denied. Please run with Administrator privileges." -Category PermissionDenied -Exception (New-Object System.Security.SecurityException)
        exit 1
    }

    if (-not (Test-Path $OfficeInstallDownloadPath )) {
        New-Item -Path $OfficeInstallDownloadPath -ItemType Directory | Out-Null
    }

    if (-not ($ConfigurationXMLFile)) {
        Set-XMLFile
    }
    else {
        Invoke-Download -URL $ConfigurationXMLFile -Path "$OfficeInstallDownloadPath\OfficeInstall.xml"
    }

    $ConfigurationXMLFile = "$OfficeInstallDownloadPath\OfficeInstall.xml"
    $ODTInstallLink = Get-ODTURL

    #Download the Office Deployment Tool
    Write-Host 'Downloading the Office Deployment Tool...'
    Invoke-Download -URL $ODTInstallLink -Path "$OfficeInstallDownloadPath\ODTSetup.exe"

    #Run the Office Deployment Tool setup
    try {
        Write-Host 'Running the Office Deployment Tool...'
        Start-Process "$OfficeInstallDownloadPath\ODTSetup.exe" -ArgumentList "/quiet /extract:$OfficeInstallDownloadPath" -Wait -NoNewWindow
    }
    catch {
        Write-Warning 'Error running the Office Deployment Tool. The error is below:'
        Write-Warning $_
        exit 1
    }

    #Run the O365 install
    try {
        Write-Host 'Downloading and installing Microsoft 365'
        $Install = Start-Process "$OfficeInstallDownloadPath\Setup.exe" -ArgumentList "/configure $ConfigurationXMLFile" -Wait -PassThru -NoNewWindow

        if ($Install.ExitCode -ne 0) {
            Write-Error -Message "Exit Code does not indicate success!" -Category InvalidResult -Exception (New-Object System.Deployment.Application.DeploymentException)
            exit 1
        }
    }
    Catch {
        Write-Warning 'Error running the Office install. The error is below:'
        Write-Warning $_
    }

    $OfficeInstalled = Find-UninstallKey -DisplayName "Microsoft 365"

    if ($CleanUpInstallFiles) {
        Write-Host "Cleaning up install files..."
        Remove-Item -Path $OfficeInstallDownloadPath -Force -Recurse
    }

    if ($OfficeInstalled) {
        Write-Host "$($OfficeInstalled.DisplayName) installed successfully!"
        if ($Restart) { Start-Process shutdown.exe -ArgumentList "-r -t 60" -Wait -NoNewWindow }
        exit 0
    }
    else {
        Write-Error -Message 'Microsoft 365 was not detected after the install ran!' -Category InvalidResult -Exception (New-Object System.Deployment.Application.DeploymentException)
        exit 1
    }
}
end {}

 

Exemples de scénarios de script

Scénario 1 : Déploiement à grande échelle

Supposons que vous soyez administrateur informatique dans une entreprise qui s’apprête à accueillir une centaine de nouveaux employés. Il serait fastidieux d’installer manuellement Office 365 sur chaque ordinateur. A la place, vous pouvez utiliser ce script PowerShell pour automatiser le processus. En utilisant NinjaOne pour exécuter le script à distance sur chaque appareil, vous pouvez standardiser vos installations Office 365 sur l’ensemble du réseau. Cette approche rationalisée permet non seulement de gagner un temps précieux, mais aussi de garantir l’uniformité, une caractéristique essentielle pour gérer efficacement une grande infrastructure informatique.

Découvrez comment NinjaOne peut améliorer l’efficacité de votre infrastructure informatique.  

Lien : https://www.ninjaone.com/fr/efficacite/

Scénario 2 : Travail à distance 

Avec l’essor du travail à distance, de nombreuses entreprises ont des employés qui travaillent à partir de différents endroits sur leurs propres appareils. S’assurer que chaque travailleur à distance dispose d’une version d’Office 365 correctement installée et configurée peut être un challenge. En distribuant ce script PowerShell à vos collaborateurs travaillant à distance, ils peuvent effectuer l’installation eux-mêmes. Le script permet de s’assurer qu’Office 365 est installé correctement et configuré selon les normes de votre entreprise.

Scénario 3 : Gestion des clients MSP

En tant que fournisseur de services gérés (MSP) vous pouvez être amené à gérer l’informatique de plusieurs petites entreprises, chacune ayant des besoins et des configurations particulières. Ce script PowerShell vous permet de créer plusieurs fichiers de configuration XML adaptés aux besoins de chaque client. Lorsque vous devez installer ou mettre à jour Office 365 pour un client, il suffit d’exécuter le script avec le fichier de configuration approprié . Cela garantit une installation personnalisée et cohérente d’Office 365 pour chacun de vos clients. 

Scénario 4 : Mises à jour régulières  

Office 365 est régulièrement mis à jour par Microsoft, et maintenir les installations de votre entreprise à jour peut être une tâche fastidieuse. Grâce à ce script, vous pouvez programmer des mises à jour automatisées qui s’exécuteront à un moment opportun, en veillant à perturber le moins possible le flux de travail de votre équipe. Le script utilise l’outil de déploiement d’Office pour télécharger et installer la dernière version d’Office 365, afin que votre équipe ait toujours accès aux dernières fonctionnalités et mises à jour de sécurité. 

Dans chacun de ces scénarios, ce script PowerShell peut simplifier considérablement le processus d’installation et de gestion d’Office 365. En automatisant ces tâches, vous pouvez gagner du temps, réduire le risque d’erreurs et garantir une expérience Office 365 cohérente et fiable à vos utilisateurs. 

Utilisation du script dans votre flux de travail

L’intégration de ce script PowerShell dans votre flux de travail peut simplifier le processus de déploiement d’Office 365. Au lieu de télécharger et d’exécuter manuellement l’outil de déploiement d’Office sur chaque machine, le script peut être exécuté à distance à partir d’un emplacement central. Cela réduit les risques d’erreur humaine et garantit une configuration standard dans toutes les installations.

De plus, en personnalisant le fichier de configuration XML, vous pouvez adapter l’installation d’Office 365 aux besoins de votre entreprise. Il s’agit notamment de spécifier la version d’Office 365, le canal de mise à jour et même les différents composants Office à installer.

Conclusions

L’automatisation est le meilleur ami des professionnels de l’informatique, et PowerShell offre un moyen puissant d’automatiser les installations d’Office 365. Ce script pratique ne se contente pas de rationaliser le processus de déploiement, il offre également des options de personnalisation et des fonctionnalités de nettoyage.

En intégrant ce script dans votre flux de travail, vous pouvez réduire considérablement le temps et les efforts consacrés à la gestion des installations d’Office 365 sur votre réseau. Alors, profitez de la puissance de PowerShell et faites des déploiements d’Office 365 un jeu d’enfant.

NinjaOne peut rationaliser vos opérations en automatisant les tâches répétitives et fastidieuses. Son interface conviviale permet aux techniciens de tous niveaux d’appliquer facilement l’automatisation sur les terminaux, y compris les scripts personnalisés à partir d’une vaste bibliothèque, ce qui rend la remédiation simple et intuitive. Comme le souligne Chris Hesler, de Crossroads Church, « NinjaOne nous a aidés à réduire le nombre d’heures de travail… nous sommes en mesure d’apporter plus d’automatisation grâce à la bibliothèque de scripts pour résoudre nos problèmes récurrents ». Découvrez le pouvoir de transformation de l’automatisation de vos opérations informatiques avec NinjaOne, un outil conçu pour être flexible et intuitif.