Verwenden von PowerShell zum Automatisieren von Office 365-Installationen

In der schnelllebigen und anspruchsvollen Welt der IT ist jedes Tool, das Zeit spart und Aufgaben vereinfacht, Gold wert. Heute werden wir untersuchen, wie PowerShell-Skripte zur Automatisierung der Installation von Office 365 verwendet werden können – ein wichtiger Vorgang, der Ihnen auf lange Sicht unzählige Stunden ersparen kann. Mit einem gut geschriebenen Skript können Sie sogar Installationen in einem ganzen Netzwerk von Ihrem Schreibtisch aus verwalten. Dieser Beitrag richtet sich an IT-Experten und Managed Service Provider (MSPs), die ihre Office 365-Bereitstellungen mithilfe der PowerShell optimieren möchten.

Warum mit PowerShell automatisieren?

PowerShell ist eine fortgeschrittene Skriptsprache und Shell, die von Microsoft entwickelt wurde. Es ist seit Windows 7 ein integraler Bestandteil des Windows-Ökosystems, und seine Leistungsfähigkeit und Flexibilität haben es zu einem unverzichtbaren Tool für viele IT-Profis und MSPs gemacht. Die Automatisierung von Office 365-Installationen mit PowerShell kann den Zeit- und Arbeitsaufwand für die Bereitstellung von Office 365 auf mehreren Computern drastisch reduzieren. 

Außerdem können PowerShell-Skripte an Ihre Bedürfnisse angepasst werden. Das Skript kann zum Beispiel so konfiguriert werden, dass es bestimmte Office 365-Komponenten installiert, bestimmte Einstellungen anwendet und sogar nach der Installation aufräumt. Dank dieser Anpassungsmöglichkeiten können IT-Experten und MSPs sicherstellen, dass Office 365 auf allen Rechnern einheitlich bereitgestellt wird und mit den IT-Richtlinien und -Standards des Unternehmens übereinstimmt. 

Ein tieferer Einblick in das PowerShell-Skript Install Office 365

Schauen wir uns ein PowerShell-Beispielskript für die Automatisierung von Office 365-Installationen genauer an. Dieses Skript wurde entwickelt, um Office 365 entweder mit einer benutzerdefinierten Konfigurationsdatei oder einer Standardkonfigurationsdatei zu installieren. Falls eine Installation fehlschlägt, gibt das Skript eine Fehlermeldung aus, was die Fehlersuche erleichtert.

Was dieses Skript besonders nützlich macht, ist seine Fähigkeit, das Office Deployment Tool von den Microsoft-Servern herunterzuladen und zu verwenden. Diese Funktion stellt sicher, dass immer die neueste Version von Office 365 für die Installation verwendet wird. Außerdem prüft das Skript, ob die Office 365-Suite korrekt installiert wurde, was eine zusätzliche Sicherheit bietet.

Nach einer erfolgreichen Installation löst das Skript einen Neustart des Systems aus. Dies ist besonders praktisch, da einige Office 365-Komponenten einen Neustart des Systems erfordern, um korrekt zu funktionieren. Das Skript ist außerdem mit einem Bereinigungsmechanismus ausgestattet, der aktiviert werden kann, um Installationsdateien nach der Installation von Office 365 zu entfernen.

PowerShell-Skript für die Installation von 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 {}

 

Skript-Beispielszenarien

Szenario 1: Bereitstellung im großen Maßstab

Nehmen wir an, Sie sind IT-Administrator in einem Unternehmen, das hundert neue Mitarbeiter:innen einstellen will. Die manuelle Installation von Office 365 auf jedem Computer wäre eine entmutigende Aufgabe. Stattdessen können Sie dieses PowerShell-Skript verwenden, um den Vorgang zu automatisieren. Wenn Sie NinjaOne verwenden, um das Skript auf jedem Gerät aus der Ferne auszuführen, können Sie Ihre Office 365 Installationen im gesamten Netzwerk standardisieren. Dieser rationelle Ansatz spart nicht nur wertvolle Zeit, sondern garantiert auch Einheitlichkeit – ein wesentliches Merkmal für die effektive Verwaltung einer großen IT-Infrastruktur.

Erfahren Sie mehr darüber, wie NinjaOne die Effizienz Ihrer IT-Infrastruktur verbessern kann.  

Link: https://www.ninjaone.com/de/effizienz

Szenario 2: Ferngesteuerte Arbeitskräfte 

Mit der Zunahme der Remotearbeit haben viele Unternehmen Mitarbeiter:innen, die von verschiedenen Standorten aus mit ihren eigenen Geräten arbeiten. Es kann eine Herausforderung sein, sicherzustellen, dass jeder Remote-Mitarbeiter eine korrekt installierte und konfigurierte Version von Office 365 hat. Wenn Sie dieses PowerShell-Skript an Ihre Remote-Mitarbeiter:innen verteilen, können diese die Installation selbst durchführen. Das Skript stellt sicher, dass Office 365 korrekt installiert und gemäß den Standards Ihres Unternehmens konfiguriert wird.

Szenario 3: MSP-Kundenmanagement

Als Managed Service Provider (MSP) verwalten Sie möglicherweise die IT für mehrere kleine Unternehmen, von denen jedes seine eigenen spezifischen Anforderungen und Konfigurationen hat. Mit diesem PowerShell-Skript können Sie mehrere XML-Konfigurationsdateien erstellen, die auf die Bedürfnisse der einzelnen Clients zugeschnitten sind. Wenn esan der Zeit ist, Office 365 für einen Client zu installieren oder zu aktualisieren, führen Sie einfach das Skript mit der entsprechenden Konfigurationsdatei aus. Dies gewährleistet eine individuelle und konsistente Office 365-Einrichtung für jeden Ihrer Kunden. 

Szenario 4: Regelmäßige Updates  

Office 365 wird von Microsoft regelmäßig aktualisiert, und die Installationen Ihres Unternehmens auf dem neuesten Stand zu halten kann eine zeitraubende Aufgabe sein. Mit diesem Skript können Sie automatische Aktualisierungen so planen, dass sie zu einem geeigneten Zeitpunkt ausgeführt werden und den Arbeitsablauf Ihres Teams nur minimal stören. Das Skript verwendet das Office Deployment Tool, um die neueste Version von Office 365 herunterzuladen und zu installieren, so dass Ihr Team immer Zugriff auf die neuesten Funktionen und Sicherheitsupdates hat. 

In jedem dieser Szenarien kann dieses PowerShell-Skript den Prozess der Installation und Verwaltung von Office 365 erheblich vereinfachen. Durch die Automatisierung dieser Aufgaben können Sie Zeit sparen, das Risiko von Fehlern verringern und eine konsistente und zuverlässige Office 365-Erfahrung für Ihre Benutzer:innen sicherstellen. 

Verwendung des Skripts in Ihrem Arbeitsablauf

Die Integration dieses PowerShell-Skripts in Ihren Arbeitsablauf kann den Prozess der Bereitstellung von Office 365 vereinfachen. Anstatt das Office Deployment Tool auf jedem Rechner manuell herunterzuladen und auszuführen, kann das Skript von einem zentralen Standort aus ausgeführt werden. Dadurch wird die Gefahr menschlicher Fehler verringert und eine Standardkonfiguration für alle Installationen gewährleistet.

Darüber hinaus können Sie durch die Anpassung der XML-Konfigurationsdatei die Office 365-Installation an die Bedürfnisse Ihres Unternehmens anpassen. Dazu gehört die Angabe der Office 365-Version, des Updatekanals und sogar der einzelnen zu installierenden Office-Komponenten.

Abschließende Überlegungen

Automatisierung ist der beste Freund eines IT-Profis, und PowerShell bietet eine leistungsstarke Möglichkeit zur Automatisierung von Office 365-Installationen. Dieses praktische Skript rationalisiert nicht nur den Bereitstellungsprozess, sondern bietet auch Anpassungsoptionen und Bereinigungsfunktionen.

Durch die Integration dieses Skripts in Ihren Arbeitsablauf können Sie den Zeit- und Arbeitsaufwand für die Verwaltung von Office 365-Installationen in Ihrem Netzwerk erheblich reduzieren. Nutzen Sie also die PowerShell und machen Sie Office 365-Bereitstellungen zu einem Kinderspiel.

NinjaOne kann Ihre Arbeitsabläufe durch die Automatisierung sich wiederholender und zeitaufwändiger Aufgaben rationalisieren. Dank der benutzerfreundlichen Oberfläche können Techniker:innen aller Ebenen problemlos Automatisierungen auf Endpunkte anwenden, einschließlich benutzerdefinierter Skripte aus einer umfangreichen Bibliothek, was die Wartung einfach und intuitiv macht. Wie Chris Hesler von Crossroads Church sagte: „NinjaOne hat geholfen, … unsere Arbeitsstunden zu reduzieren … wir sind in der Lage, mit der Skriptbibliothek mehr zu automatisieren, um unsere wiederkehrenden Probleme zu lösen.“ Entdecken Sie die transformative Kraft der Automatisierung in Ihrem IT-Betrieb mit NinjaOne, einem Tool, das auf Flexibilität und Intuitivität aufgebaut ist.