Hoe PowerShell gebruiken om Office 365-installaties te automatiseren

In de snelle en veeleisende wereld van IT is elke tool die tijd bespaart en taken vereenvoudigt goud waard. Vandaag gaan we onderzoeken hoe PowerShell scripts kunnen worden gebruikt om de installatie van Office 365 te automatiseren, een cruciale operatie die je op de lange termijn talloze uren kan besparen. Met een goed geschreven script kunt u zelfs installaties over een heel netwerk beheren vanaf uw bureau. Dit bericht is bedoeld voor IT-professionals en Managed Service Providers (MSP’s) die hun Office 365-implementaties willen stroomlijnen met behulp van de kracht van PowerShell.

Waarom automatiseren met PowerShell?

PowerShell is een geavanceerde scripttaal en shell, ontwikkeld door Microsoft. Het is een integraal onderdeel van het Windows ecosysteem sinds Windows 7, en de kracht en flexibiliteit hebben het een essentieel hulpmiddel gemaakt voor veel IT-professionals en MSP’s. Het automatiseren van Office 365-installaties met PowerShell kan de tijd en moeite die nodig zijn om Office 365 op meerdere machines te implementeren drastisch verminderen. 

Bovendien kunnen PowerShell-scripts worden aangepast aan uw behoeften. Het script kan bijvoorbeeld worden geconfigureerd om specifieke Office 365 componenten te installeren, bepaalde instellingen toe te passen en zelfs op te ruimen na de installatie. Met dit niveau van maatwerk kunnen IT-professionals en MSP’s ervoor zorgen dat Office 365 consistent wordt geïmplementeerd op alle machines, in overeenstemming met het IT-beleid en de IT-standaarden van het bedrijf. 

Dieoer ingaan op PowerShell Office 365-script installeren

Laten we eens kijken naar een voorbeeld PowerShell script voor het automatiseren van Office 365 installaties. Dit script is ontworpen om Office 365 te installeren met behulp van een aangepast configuratiebestand of een standaard configuratiebestand. In het geval dat een installatie mislukt, zal het script een foutmelding geven, waardoor het oplossen van problemen eenvoudiger wordt.

Wat dit script bijzonder nuttig maakt, is de mogelijkheid om de Office Deployment Tool van de servers van Microsoft te downloaden en te gebruiken. Deze functie zorgt ervoor dat altijd de nieuwste versie van Office 365 wordt gebruikt voor de installatie. Bovendien controleert het script of de Office 365-suite correct is geïnstalleerd, wat een extra zekerheid biedt.

Na een succesvolle installatie start het script het systeem opnieuw op. Dit is vooral handig omdat sommige onderdelen van Office 365 een herstart van het systeem vereisen om correct te functioneren. Het script is ook uitgerust met een opschoonmechanisme dat kan worden geactiveerd om installatiebestanden te verwijderen nadat Office 365 is geïnstalleerd.

Microsoft Office 365 Installatie PowerShell Script

#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 {}

 

Scriptvoorbeeldscenario’s

Scenario 1: Grootschalige implementatie

Stel dat u een IT-beheerder bent in een bedrijf dat op het punt staat honderd nieuwe werknemers aan te nemen. Office 365 handmatig installeren op elke computer zou een ontmoedigende taak zijn. In plaats daarvan kunt u dit PowerShell-script gebruiken om het proces te automatiseren. Door NinjaOne te gebruiken om het script op afstand op elk apparaat uit te voeren, kunt u Office 365-installaties in het gehele netwerk standaardiseren. Deze gestroomlijnde aanpak bespaart niet alleen kostbare tijd, maar garandeert ook uniformiteit, een essentiële eigenschap voor het effectief beheren van een grote IT-infrastructuur.

Lees meer over hoe NinjaOne de efficiëntie van uw IT-infrastructuur kan verbeteren.  

Link: https://www.ninjaone.com/nl/efficientie/

Scenario 2: Personeel op afstand 

Met de opkomst van werken op afstand hebben veel bedrijven werknemers die vanaf verschillende locaties op hun eigen apparaten werken. Het kan een uitdaging zijn om ervoor te zorgen dat elke externe medewerker een correct geïnstalleerde en geconfigureerdeversie van Office 365 heeft. Door dit PowerShell script te verspreiden onder uw externe medewerkers, kunnen ze de installatie zelf uitvoeren. Het script zorgt ervoor dat Office 365 correct wordt geïnstalleerd en geconfigureerd op basis van de standaarden van uw organisatie.

Scenario 3: MSP-klantbeheer

Als Managed Service Provider (MSP) beheert u mogelijk de IT voor verschillende kleine bedrijven, elk met hun eigen specifieke behoeften en configuraties. Met dit PowerShell-script kunt u meerdere XML-configuratiebestanden maken die zijn afgestemd op de behoeften van elke klant. Wanneer het tijd is om Office 365 voor een klant te installeren of bij te werken, voert u gewoon het script uit met het juiste configuratie bestand. Dit zorgt voor een aangepaste en consistente Office 365 setup voor elk van uw klanten. 

Scenario 4: Regelmatige updates  

Office 365 wordt regelmatig bijgewerkt door Microsoft en hetup-to-datehouden van de installaties van je organisatie op kan een tijdrovende klus zijn. Met dit script kunt u automatische updates plannen om op een geschikt moment uit te voeren, zodat de workflow van uw team zo min mogelijk wordt verstoord. Het script gebruikt de Office Deployment Tool om de nieuwste versie van Office 365 te downloaden en te installeren, zodat uw team altijd toegang heeft tot de nieuwste functies en beveiligingsupdates. 

In elk van deze scenario’s kan dit PowerShell script het installatie- en beheerproces van Office 365 aanzienlijk vereenvoudigen. Door deze taken te automatiseren, kunt u tijd besparen, de kans op fouten verkleinen en zorgen voor een consistente en betrouwbare Office 365-ervaring voor uw gebruikers. 

Het script gebruiken in uw workflow

Door dit PowerShell-script in uw workflow te integreren, kunt u het implementatieproces van Office 365 vereenvoudigen. In plaats van het handmatig downloaden en uitvoeren van de Office Deployment Tool op elke machine, kan het script op afstand worden uitgevoerd vanaf een centrale locatie. Dit verkleint de kans op menselijke fouten en zorgt voor een standaardconfiguratie in alle installaties.

Bovendien kunt u door het XML-configuratiebestand aan te passen de Office 365-installatie aanpassen aan de behoeften van uw organisatie. Dit omvat het specificeren van de Office 365-versie, het updatekanaal en zelfs de afzonderlijke Office-onderdelen die moeten worden geïnstalleerd.

Slotbeschouwingen:

Automatisering is de beste vriend van een IT-professional en PowerShell biedt een krachtige manier om Office 365-installaties te automatiseren. Dit handige script stroomlijnt niet alleen het implementatieproces, maar biedt ook aanpassingsopties en opruimfunctionaliteit.

Door dit script in uw workflow te integreren, kunt u de tijd en moeite die gemoeid zijn met het beheren van Office 365-installaties in uw netwerk aanzienlijk verminderen. Omarm dus de kracht van PowerShell en maak van Office 365 implementaties een fluitje van een cent.

NinjaOne kunt u activiteiten stroomlijnen door repetitieve en tijdrovende taken te automatiseren. Dankzij de gebruiksvriendelijke interface kunnen technici van alle niveaus eenvoudig automatisering toepassen op endpoints, inclusief aangepaste scripts uit een uitgebreide bibliotheek, waardoor herstel eenvoudig en intuïtief is. Zoals Chris Hesler van Crossroads Church opmerkte: “NinjaOne heeft ons geholpen… de manuren te verminderen… we zijn in staat meer automatisering toe te passen met de scriptbibliotheek om onze terugkerende problemen op te lossen.” Ontdek de transformerende kracht van automatisering in uw IT-activiteiten met NinjaOne, een tool die is ontworpen met flexibiliteit en intuïtiviteit als uitgangspunt.