Scripting Framework Engine über Intune/Autopilot installieren - Windows Client Management AG

Allgemein

Um mit dem Microsoft Intune Scripting Framework Pakete installieren zu können, muss die Scripting Framework Engine auf dem Client installiert sein. Die Dokumentation beschreibt, wie der Rollout der SF Engine per Intune auf die Geräte durchgeführt werden kann.

Für den Rollout der Engine wird ein PowerShell-Skript verwendet, das in Intune integriert wird. PowerShell-Skripte werden vor der Ausführung von Win32-Apps ausgeführt. Dadurch wird sichergestellt, dass die SF Engine vor der ersten Installation einer Anwendung installiert ist:

PowerShell scripts are executed before Win32 apps run. In other words, PowerShell scripts execute first. Then, Win32 apps execute.
https://docs.microsoft.com/en-us/mem/intune/apps/intune-management-extension

Das PowerShell-Skript „Install-ScriptingFrameworkEngine.ps1“ lädt die Scripting Framework Engine von einer URL herunter und führt anschliessend die Installation aus:

Function Download-File
{
    param($URL, $Destination)

    # Log
    Write-Log "Download-File" -Severity Info

    # Fix: Could not create SSL/TLS secure channel
    [Net.ServicePointManager]::SecurityProtocol = 'Tls12' 

    # Get Proxy Settings
    Write-Log "Get Proxy Settings" -Severity Info
    $dest = "https://www.google.ch"
    $proxy = ([System.Net.WebRequest]::GetSystemWebproxy()).GetProxy($dest)
    $proxyurl = $proxy.OriginalString
    if ($proxyurl -eq $dest)
    {
        $proxyurl = $null
    }
    Write-Log "ProxyURL: $($proxyurl)" -Severity Info

    # Test Destination
    if(Test-Path -Path $Destination){Remove-Item -Path $Destination -ErrorAction SilentlyContinue}
    
    # Download Office Deployment Tool
    Write-Log "Download File: $($URL)" -Severity Info
    Write-Log "Destination: $($Destination)" -Severity Info
    try
    {
        Write-Log "The download is in progress, please wait..." -Severity Info
        Invoke-WebRequest -UseBasicParsing -Uri $URL -OutFile $Destination -Proxy $proxyurl -ErrorAction Stop
    }
    catch
    {
        Write-Log "$($_.Exception.Message)" -Severity Error
        Return $false
    }

    # Show File Size
    $FileSizeMB = ((Get-Item $Destination).length/1MB) # returns file length in MB
    Write-Log "File Size (MB): $($FileSizeMB)" -Severity Info

    # Unblock File
    Write-Log "Unblock File" -Severity Info
    Unblock-File -Path $Destination -ErrorAction SilentlyContinue

    # Success
    Return $true
}

Function Initialize-Log
{
    param ($Filename)

    # Create LogFile
    $Script:Logfile = "$([Environment]::GetEnvironmentVariable("Temp", "Machine"))\$($Filename).log"
    If (Test-Path $Script:Logfile)
    {
	    $LogFilePropertys = Get-Item $Script:Logfile
	    If ($LogFilePropertys.length/1KB -gt 1024)
	    {
		    Remove-Item -Path $Script:Logfile
	    }
    }
    Write-Log "Initialize" -Severity Title
}

Function Write-Log
{
	Param ([Parameter(Mandatory = $true)]
		$Message,
		[ValidateSet('Error', 'Info', 'Warning', 'Title')]
		[string]$Severity = "Custom"
	)
	
	$date = Get-Date -Format dd:MM:yyyy-HH:mm:ss
	
	# Create Message String
	if ($Severity -eq "Title")
	{
		[int]$CharsCount = (120 - $Message.Length)
		$Message = "$date    ***** $Message " + "*" * $CharsCount
	}
	elseif ($Severity -eq "Error")
	{
		$Message = "$date   ERROR: $Message"
	}
	elseif ($Severity -eq "Warning")
	{
		$Message = "$date WARNING: $Message"
	}
	else
	{
		$Message = "$date    INFO: $Message"
	}
	
	Write-Output $Message | Out-File $Script:Logfile -Append -ErrorAction 'SilentlyContinue'
	Write-Host $Message
}

# Parameters
$StartInstallation = $false

# Check License
If (Test-Path "$($env:windir)\_ScriptingFramework\Modul\License.lic" -ErrorAction SilentlyContinue)
{
    # Read License File
    $LicenseFile = Get-Content "$($env:windir)\_ScriptingFramework\Modul\License.lic" -ErrorAction 'SilentlyContinue'
    $LicenseExpireDate = [datetime]::ParseExact($($LicenseFile.Split("|")[1]), "dd.MM.yyyy", $null)
    
    # Check if the license is expiring soon
    If ((Get-Date).AddDays(+30) -ge $LicenseExpireDate)
    {
        # License Expired
        $StartInstallation = $true
    }
}
Else
{
    $StartInstallation = $true
}

# Check if the SF Engine exist
If (-not (Test-Path "$($env:windir)\_ScriptingFramework\Modul\Engine.exe" -ErrorAction SilentlyContinue))
{
    $StartInstallation = $true
}

# Check for Action
If ($StartInstallation -eq $false)
{
    # No Action
    Write-Host "No action is required on the client"
    Return
}

# Initialize Log
Initialize-Log -Filename "Install-ScriptingFrameworkEngine"

# Log
Write-Log "START Installation" -Severity Title

# Download
$ZipFileName = "Scripting_Framework_Engine.zip"
$Result = Download-File -URL "https://www.scriptingframework.ch/$($ZipFileName)" -Destination "filesystem::$($env:temp)\$($ZipFileName)"
If ($Result -eq $false)
{
    Write-Log "Download error" -Severity Error
    [Environment]::Exit(1603)
}

# Expand Source
Write-Log "Expand Archive to: $($env:temp)\SFEngine" -Severity Info
Expand-Archive -LiteralPath "$($env:temp)\$($ZipFileName)" -DestinationPath "$($env:temp)\SFEngine" -Force

# Execute Setup
Write-Log "Start Scripting Framework Setup: $($env:temp)\SFEngine\Install.cmd" -Severity Info
$Process = Start-Process -FilePath "filesystem::$($env:temp)\SFEngine\Install.cmd" -WindowStyle Hidden -PassThru -Wait
Write-Log "Exit Code: $($Process.ExitCode)" -Severity Info

# Remove Files
Write-Log "Remove Files" -Severity Info
Remove-Item -Path "$($env:temp)\SFEngine" -ErrorAction SilentlyContinue -Force -Recurse
Remove-Item -Path "$($env:temp)\$($ZipFileName)" -ErrorAction SilentlyContinue -Force

# Log
Write-Log "END Installation" -Severity Title

Scripting Framework Engine vorbereiten

Die Installationsdateien von dem Scripting Framework Engine Paket werden inklusive der Lizenzdatei in eine ZIP-Datei mit dem Namen „Scripting_Framework_Engine.zip“ gepackt:

Die erstellte ZIP-Datei „Scripting_Framework_Engine.zip“ wird nun auf einem Webserver bereitgestellt, der auch von extern erreichbar ist. Zum Beispiel: https://www.scriptingframework.ch/Scripting_Framework_Engine.zip.

Intune – PowerShell Script für die Engine Installation

Der PowerShell-Skript führt auf den Intune-Clients die Installation der SF Engine durch. Die Funktionsweise ist dabei wie folgt:

Herunterladen der erstellten ZIP-Datei, zum Beispiel von https://www.scriptingframework.ch/Scripting_Framework_Engine.zip
Extrahieren der Zip-Datei
Ausführen der Install.cmd, die in der ZIP-Datei enthalten ist
Bereinigung

Alle Aktionen werden in einem Log protokolliert: C:\Windows\Temp\Install-ScriptingFrameworkEngine.log.

Das PowerShell-Skript „Install-ScriptingFrameworkEngine.ps1“ für die Installation der Engine auf den Geräten wird nun im Intune-Portal registriert: