windows based runner vm fails to provision in azure

[rgl]

The windows based runner vm fails to provision because the CustomScriptExtension extension fails with exit code 1.

The pool is created as (full example is at https://github.com/rgl/terraform-azure-garm/tree/wip-windows-runner):

./garm-cli pool create \
  --enabled true \
  --org "$org_id" \
  --min-idle-runners 0 \
  --max-runners 2 \
  --tags garm-org-azure-amd64-windows-2022 \
  --runner-prefix rgl-garm-windows-org \
  --provider-name azure \
  --os-arch amd64 \
  --os-type windows \
  --flavor Standard_F2s_v2 \
  --image MicrosoftWindowsServer:WindowsServer:2022-Datacenter:latest \
  --extra-specs '{
    "storage_account_type": "StandardSSD_LRS",
    "disk_size_gb": 127
  }'

But the runner vm ends up failing the provisioning.

Here's the stripped down error message:

    <S S="Error">User runner already exists._x000D__x000A_</S>
    <S S="Error">At C:\run.ps1:333 char:3_x000D__x000A_</S>
    <S S="Error">+         Throw $Message_x000D__x000A_</S>
    <S S="Error">+         ~~~~~~~~~~~~~~_x000D__x000A_</S>
    <S S="Error">    + CategoryInfo          : OperationStopped: (User runner already exists.:String) [], RuntimeException_x000D__x000A_</S>
    <S S="Error">    + FullyQualifiedErrorId : User runner already exists._x000D__x000A_</S>
    <S S="Error"> _x000D__x000A_</S>

Here's the full error message:

#< CLIXML
<Objs Version="1.1.0.1"
    xmlns="http://schemas.microsoft.com/powershell/2004/04">
    <Obj S="progress" RefId="0">
        <TN RefId="0">
            <T>System.Management.Automation.PSCustomObject</T>
            <T>System.Object</T>
        </TN>
        <MS>
            <I64 N="SourceId">1</I64>
            <PR N="Record">
                <AV>Preparing modules for first use.</AV>
                <AI>0</AI>
                <Nil />
                <PI>-1</PI>
                <PC>-1</PC>
                <T>Completed</T>
                <SR>-1</SR>
                <SD></SD>
            </PR>
        </MS>
    </Obj>
    <Obj S="progress" RefId="1">
        <TNRef RefId="0" />
        <MS>
            <I64 N="SourceId">2</I64>
            <PR N="Record">
                <AV>Preparing modules for first use.</AV>
                <AI>0</AI>
                <Nil />
                <PI>-1</PI>
                <PC>-1</PC>
                <T>Completed</T>
                <SR>-1</SR>
                <SD></SD>
            </PR>
        </MS>
    </Obj>
    <Obj S="progress" RefId="2">
        <TNRef RefId="0" />
        <MS>
            <I64 N="SourceId">3</I64>
            <PR N="Record">
                <AV>Preparing modules for first use.</AV>
                <AI>0</AI>
                <Nil />
                <PI>-1</PI>
                <PC>-1</PC>
                <T>Completed</T>
                <SR>-1</SR>
                <SD></SD>
            </PR>
        </MS>
    </Obj>
    <Obj S="progress" RefId="3">
        <TNRef RefId="0" />
        <MS>
            <I64 N="SourceId">3</I64>
            <PR N="Record">
                <AV>Preparing modules for first use.</AV>
                <AI>0</AI>
                <Nil />
                <PI>-1</PI>
                <PC>-1</PC>
                <T>Completed</T>
                <SR>-1</SR>
                <SD></SD>
            </PR>
        </MS>
    </Obj>
    <Obj S="progress" RefId="4">
        <TNRef RefId="0" />
        <MS>
            <I64 N="SourceId">4</I64>
            <PR N="Record">
                <AV>Reading web response</AV>
                <AI>174593042</AI>
                <Nil />
                <PI>-1</PI>
                <PC>-1</PC>
                <T>Processing</T>
                <SR>-1</SR>
                <SD>Reading response stream... (Number of bytes read: 0)</SD>
            </PR>
        </MS>
    </Obj>
    <Obj S="progress" RefId="5">
        <TNRef RefId="0" />
        <MS>
            <I64 N="SourceId">4</I64>
            <PR N="Record">
                <AV>Reading web response</AV>
                <AI>174593042</AI>
                <Nil />
                <PI>-1</PI>
                <PC>-1</PC>
                <T>Completed</T>
                <SR>-1</SR>
                <SD>Reading web response completed. (Number of bytes read: 0)</SD>
            </PR>
        </MS>
    </Obj>
    <S S="Error">User runner already exists._x000D__x000A_</S>
    <S S="Error">At C:\run.ps1:333 char:3_x000D__x000A_</S>
    <S S="Error">+         Throw $Message_x000D__x000A_</S>
    <S S="Error">+         ~~~~~~~~~~~~~~_x000D__x000A_</S>
    <S S="Error">    + CategoryInfo          : OperationStopped: (User runner already exists.:String) [], RuntimeException_x000D__x000A_</S>
    <S S="Error">    + FullyQualifiedErrorId : User runner already exists._x000D__x000A_</S>
    <S S="Error"> _x000D__x000A_</S>
</Objs>

[gabriel-samfira]

quick question. Are you using a custom image that already has a user called "runner" ?

[gabriel-samfira]

We updated the userdata for windows in this PR:

cloudbase/garm-provider-common#46

The TL;DR is that we now use a regular user, added to the local Administrators group and with SeServiceLoginRight privilege set. This should cover the most use cases for any runner.

I don't think we retry creating the user, so one potential explanation is that the image you're using already has the "runner" user. One quick way to test is to overwrite the install template by running:

garm-cli pool update --extra-specs-file $HOME/specs.json <pool ID>

and in $HOME/specs.json you can add:

{
	"runner_install_template": "#ps1_sysnative
Param(
	[Parameter(Mandatory=$false)]
	[string]$Token="{{.CallbackToken}}"
)

$ErrorActionPreference="Stop"

function Start-ExecuteWithRetry {
    [CmdletBinding()]
    param(
        [Parameter(Mandatory=$true)]
        [ScriptBlock]$ScriptBlock,
        [int]$MaxRetryCount=10,
        [int]$RetryInterval=3,
        [string]$RetryMessage,
        [array]$ArgumentList=@()
    )
    PROCESS {
        $currentErrorActionPreference = $ErrorActionPreference
        $ErrorActionPreference = "Continue"
        $retryCount = 0
        while ($true) {
            try {
                $res = Invoke-Command -ScriptBlock $ScriptBlock -ArgumentList $ArgumentList
                $ErrorActionPreference = $currentErrorActionPreference
                return $res
            } catch [System.Exception] {
                $retryCount++

                if ($_.Exception -is [System.Net.WebException]) {
                    $webResponse = $_.Exception.Response
					# Skip retry on Error: 4XX (e.g. 401 Unauthorized, 404 Not Found etc.)
                    if ($webResponse -and $webResponse.StatusCode -ge 400 -and $webResponse.StatusCode -lt 500) {
                        # Skip retry on 4xx errors
                        Write-Output "Encountered non-retryable error (4xx): $($_.Exception.Message)"
                        $ErrorActionPreference = $currentErrorActionPreference
                        throw
                    }
                }

                if ($retryCount -gt $MaxRetryCount) {
                    $ErrorActionPreference = $currentErrorActionPreference
                    throw
                } else {
                    if ($RetryMessage) {
                        Write-Output $RetryMessage
                    } elseif ($_) {
                        Write-Output $_
                    }
                    Start-Sleep -Seconds $RetryInterval
                }
            }
        }
    }
}

function Get-RandomString {
    [CmdletBinding()]
    Param(
        [int]$Length=13
    )
    PROCESS {
        if($Length -lt 6) {
            $Length = 6
        }
        $special = @(44, 45, 46, 64)
        $numeric = 48..57
        $upper = 65..90
        $lower = 97..122

        $passwd = [System.Collections.Generic.List[object]](New-object "System.Collections.Generic.List[object]")
        for($i=0; $i -lt $Length-4; $i++){
            $c = get-random -input ($special + $numeric + $upper + $lower)
            $passwd.Add([char]$c)
        }

        $passwd.Add([char](get-random -input $numeric))
        $passwd.Add([char](get-random -input $special))
        $passwd.Add([char](get-random -input $upper))
        $passwd.Add([char](get-random -input $lower))

        $Random = New-Object Random
        return [string]::join("",($passwd|Sort-Object {$Random.Next()}))
    }
}

Add-Type -TypeDefinition @"
using System;
using System.Runtime.InteropServices;
using System.Text;

public class GrantSysPrivileges
{
    [StructLayout(LayoutKind.Sequential)]
    public struct LSA_UNICODE_STRING
    {
        public ushort Length;
        public ushort MaximumLength;
        public IntPtr Buffer;
    }

    [StructLayout(LayoutKind.Sequential)]
    public struct LSA_OBJECT_ATTRIBUTES
    {
        public int Length;
        public IntPtr RootDirectory;
        public IntPtr ObjectName;
        public uint Attributes;
        public IntPtr SecurityDescriptor;
        public IntPtr SecurityQualityOfService;
    }

    [DllImport("advapi32.dll", SetLastError=true)]
    public static extern uint LsaOpenPolicy(
        ref LSA_UNICODE_STRING SystemName,
        ref LSA_OBJECT_ATTRIBUTES ObjectAttributes,
        uint DesiredAccess,
        out IntPtr PolicyHandle
    );

    [DllImport("advapi32.dll", SetLastError=true)]
    public static extern uint LsaAddAccountRights(
        IntPtr PolicyHandle,
        IntPtr AccountSid,
        LSA_UNICODE_STRING[] UserRights,
        uint CountOfRights
    );

    [DllImport("advapi32.dll")]
    public static extern uint LsaClose(IntPtr PolicyHandle);

    [DllImport("advapi32.dll")]
    public static extern uint LsaNtStatusToWinError(uint status);

    public const uint POLICY_ALL_ACCESS = 0x00F0FFF;

    public static uint GrantPrivilege(byte[] sid, string[] rights)
    {
        LSA_OBJECT_ATTRIBUTES loa = new LSA_OBJECT_ATTRIBUTES();
        LSA_UNICODE_STRING systemName = new LSA_UNICODE_STRING();

        IntPtr policyHandle;
        uint result = LsaOpenPolicy(ref systemName, ref loa, POLICY_ALL_ACCESS, out policyHandle);
        if (result != 0)
        {
            return LsaNtStatusToWinError(result);
        }

        LSA_UNICODE_STRING[] userRights = new LSA_UNICODE_STRING[rights.Length];
        for (int i = 0; i < rights.Length; i++)
        {
            byte[] bytes = Encoding.Unicode.GetBytes(rights[i]);
            IntPtr ptr = Marshal.AllocHGlobal(bytes.Length);
            Marshal.Copy(bytes, 0, ptr, bytes.Length);

            userRights[i].Buffer = ptr;
            userRights[i].Length = (ushort)bytes.Length;
            userRights[i].MaximumLength = (ushort)(bytes.Length);
        }

        IntPtr sidPtr = Marshal.AllocHGlobal(sid.Length);
        Marshal.Copy(sid, 0, sidPtr, sid.Length);

        result = LsaAddAccountRights(policyHandle, sidPtr, userRights, (uint)rights.Length);
        LsaClose(policyHandle);

        foreach (var right in userRights)
        {
            Marshal.FreeHGlobal(right.Buffer);
        }
        Marshal.FreeHGlobal(sidPtr);

        return LsaNtStatusToWinError(result);
    }
}
"@ -Language CSharp

function Invoke-FastWebRequest {
	[CmdletBinding()]
	Param(
		[Parameter(Mandatory=$True,ValueFromPipeline=$true,Position=0)]
		[System.Uri]$Uri,
		[Parameter(Position=1)]
		[string]$OutFile,
		[Hashtable]$Headers=@{},
		[switch]$SkipIntegrityCheck=$false
	)
	PROCESS
	{
		if(!([System.Management.Automation.PSTypeName]'System.Net.Http.HttpClient').Type)
		{
			$assembly = [System.Reflection.Assembly]::LoadWithPartialName("System.Net.Http")
		}

		if(!$OutFile) {
			$OutFile = $Uri.PathAndQuery.Substring($Uri.PathAndQuery.LastIndexOf("/") + 1)
			if(!$OutFile) {
				throw "The ""OutFile"" parameter needs to be specified"
			}
		}

		$fragment = $Uri.Fragment.Trim('#')
		if ($fragment) {
			$details = $fragment.Split("=")
			$algorithm = $details[0]
			$hash = $details[1]
		}

		if (!$SkipIntegrityCheck -and $fragment -and (Test-Path $OutFile)) {
			try {
				return (Test-FileIntegrity -File $OutFile -Algorithm $algorithm -ExpectedHash $hash)
			} catch {
				Remove-Item $OutFile
			}
		}

		$client = new-object System.Net.Http.HttpClient
		foreach ($k in $Headers.Keys){
			$client.DefaultRequestHeaders.Add($k, $Headers[$k])
		}
		$task = $client.GetStreamAsync($Uri)
		$response = $task.Result
		if($task.IsFaulted) {
			$msg = "Request for URL '{0}' is faulted. Task status: {1}." -f @($Uri, $task.Status)
			if($task.Exception) {
				$msg += "Exception details: {0}" -f @($task.Exception)
			}
			Throw $msg
		}
		$outStream = New-Object IO.FileStream $OutFile, Create, Write, None

		try {
			$totRead = 0
			$buffer = New-Object Byte[] 1MB
			while (($read = $response.Read($buffer, 0, $buffer.Length)) -gt 0) {
				$totRead += $read
				$outStream.Write($buffer, 0, $read);
			}
		}
		finally {
			$outStream.Close()
		}
		if(!$SkipIntegrityCheck -and $fragment) {
			Test-FileIntegrity -File $OutFile -Algorithm $algorithm -ExpectedHash $hash
		}
	}
}

function Import-Certificate() {
	[CmdletBinding()]
	param (
		[parameter(Mandatory=$true)]
		$CertificateData,
		[parameter(Mandatory=$false)]
		[System.Security.Cryptography.X509Certificates.StoreLocation]$StoreLocation="LocalMachine",
		[parameter(Mandatory=$false)]
		[System.Security.Cryptography.X509Certificates.StoreName]$StoreName="TrustedPublisher"
	)
	PROCESS
	{
		$store = New-Object System.Security.Cryptography.X509Certificates.X509Store(
			$StoreName, $StoreLocation)
		$store.Open([System.Security.Cryptography.X509Certificates.OpenFlags]::ReadWrite)
		$cert = [System.Security.Cryptography.X509Certificates.X509Certificate2]::new($CertificateData)
		$store.Add($cert)
	}
}

function Invoke-APICall() {
	[CmdletBinding()]
	param (
		[parameter(Mandatory=$true)]
		[object]$Payload,
		[parameter(Mandatory=$true)]
		[string]$CallbackURL
	)
	PROCESS{
		Invoke-WebRequest -UseBasicParsing -Method Post -Headers @{"Accept"="application/json"; "Authorization"="Bearer $Token"} -Uri $CallbackURL -Body (ConvertTo-Json $Payload) | Out-Null
	}
}

function Update-GarmStatus() {
	[CmdletBinding()]
	param (
		[parameter(Mandatory=$true)]
		[string]$Message,
		[parameter(Mandatory=$false)]
		[int64]$AgentID=0,
		[parameter(Mandatory=$false)]
		[string]$Status="installing",
		[parameter(Mandatory=$true)]
		[string]$CallbackURL
	)
	PROCESS{
		$body = @{
			"status"=$Status
			"message"=$Message
		}

		if ($AgentID -ne 0) {
			$body["agent_id"] = $AgentID
		}
		Invoke-APICall -Payload $body -CallbackURL $CallbackURL | Out-Null
	}
}

function Invoke-GarmSuccess() {
	[CmdletBinding()]
	param (
		[parameter(Mandatory=$true)]
		[string]$Message,
		[parameter(Mandatory=$true)]
		[int64]$AgentID,
		[parameter(Mandatory=$true)]
		[string]$CallbackURL
	)
	PROCESS{
		Update-GarmStatus -Message $Message -AgentID $AgentID -CallbackURL $CallbackURL -Status "idle" | Out-Null
	}
}

function Invoke-GarmFailure() {
	[CmdletBinding()]
	param (
		[parameter(Mandatory=$true)]
		[string]$Message,
		[parameter(Mandatory=$true)]
		[string]$CallbackURL
	)
	PROCESS{
		Update-GarmStatus -Message $Message -CallbackURL $CallbackURL -Status "failed" | Out-Null
		Throw $Message
	}
}

function Set-SystemInfo {
    [CmdletBinding()]
    param (
        [parameter(Mandatory=$true)]
        [string]$CallbackURL,
        [parameter(Mandatory=$true)]
        [string]$RunnerDir,
		[parameter(Mandatory=$true)]
        [string]$BearerToken
    )

    # Construct the path to the .runner file
    $agentInfoFile = Join-Path $RunnerDir ".runner"

    # Read and parse the JSON content from the .runner file
    $agentInfo = ConvertFrom-Json (Get-Content -Raw -Path $agentInfoFile)
    $AgentId = $agentInfo.agent_id

    # Retrieve OS information
    $osInfo = Get-WmiObject -Class Win32_OperatingSystem
    $osName = $osInfo.Caption
    $osVersion = $osInfo.Version

    # Strip status from the callback URL
    if ($CallbackUrl -match '^(.*)/status(/)?$') {
        $CallbackUrl = $matches[1]
    }

    $SysInfoUrl = "$CallbackUrl/system-info/"
    $Payload = @{
        os_name    = $OSName
        os_version = $OSVersion
        agent_id   = $AgentId
    } | ConvertTo-Json

    # Send the POST request
    try {
        Invoke-RestMethod -Uri $SysInfoUrl -Method Post -Body $Payload -ContentType 'application/json' -Headers @{ 'Authorization' = "Bearer $BearerToken" } -ErrorAction Stop
    } catch {
        Write-Output "Failed to send the system information."
    }
}

$GHRunnerGroup = "{{.GitHubRunnerGroup}}"

function Install-Runner() {
	$CallbackURL="{{.CallbackURL}}"
	if (!($CallbackURL -match "^(.*)/status(/)?$")) {
		$CallbackURL = "$CallbackURL/status"
	}

	if ($Token.Length -eq 0) {
		Throw "missing callback authentication token"
	}
	try {
		$MetadataURL="{{.MetadataURL}}"
		$DownloadURL="{{.DownloadURL}}"
		if($MetadataURL -eq ""){
			Throw "missing metadata URL"
		}

		# Create user with administrator rights to run service as
		$userPasswd = Get-RandomString -Length 10
		$secPasswd = ConvertTo-SecureString "$userPasswd" -AsPlainText -Force
		New-LocalUser -Name "garmrunner" -Password $secPasswd -PasswordNeverExpires -UserMayNotChangePassword
		$pscreds = New-Object System.Management.Automation.PSCredential (".\garmrunner", $secPasswd)
		$adminGrpName = (Get-CimInstance win32_group -Filter 'SID = "S-1-5-32-544"').Name
		if (!$adminGrpName) {
			Throw "Could not find administrators group name"
		}
		Add-LocalGroupMember -Group $adminGrpName -Member runner
		$ntAcct = New-Object System.Security.Principal.NTAccount("garmrunner")
		$sid = $ntAcct.Translate([System.Security.Principal.SecurityIdentifier])
		$sidBytes = New-Object byte[] ($sid.BinaryLength)
		$sid.GetBinaryForm($sidBytes, 0)

		$result = [GrantSysPrivileges]::GrantPrivilege($sidBytes, ("SeBatchLogonRight", "SeServiceLogonRight"))
		if ($result -ne 0) {
		    Throw "Failed to grant privileges"
		}

		$bundle = wget -UseBasicParsing -Headers @{"Accept"="application/json"; "Authorization"="Bearer $Token"} -Uri $MetadataURL/system/cert-bundle
		$converted = ConvertFrom-Json $bundle
		foreach ($i in $converted.root_certificates.psobject.Properties){
			$data = [System.Convert]::FromBase64String($i.Value)
			Import-Certificate -CertificateData $data -StoreName Root -StoreLocation LocalMachine
		}

		$runnerDir = "C:\actions-runner"
		# Check if a cached runner is available
		if (-not (Test-Path $runnerDir)) {
			# No cached runner found, proceed to download and extract
			Update-GarmStatus -CallbackURL $CallbackURL -Message "downloading tools from {{ .DownloadURL }}"

			$downloadToken="{{.TempDownloadToken}}"
			$DownloadTokenHeaders=@{}
			if ($downloadToken.Length -gt 0) {
				$DownloadTokenHeaders=@{
					"Authorization"="Bearer $downloadToken"
				}
			}

			$downloadPath = Join-Path $env:TMP "{{ .FileName }}"
			Start-ExecuteWithRetry -ScriptBlock {
				Invoke-FastWebRequest -Uri "{{ .DownloadURL }}" -OutFile $downloadPath -Headers $DownloadTokenHeaders
			} -MaxRetryCount 5 -RetryInterval 5 -RetryMessage "Retrying download of runner..."

			mkdir $runnerDir
			Update-GarmStatus -CallbackURL $CallbackURL -Message "extracting runner"
			Add-Type -AssemblyName System.IO.Compression.FileSystem
			[System.IO.Compression.ZipFile]::ExtractToDirectory($downloadPath, "$runnerDir")
		} else {
			Update-GarmStatus -CallbackURL $CallbackURL -Message "using cached runner found at $runnerDir"
		}

		# Ensure runner has full access to actions-runner folder
		$runnerACL = Get-Acl $runnerDir
		$runnerACL.SetAccessRule((New-Object System.Security.AccessControl.FileSystemAccessRule(
		    "garmrunner", "FullControl", "ContainerInherit,ObjectInherit", "None", "Allow"
		)))
		Set-Acl -Path $runnerDir -AclObject $runnerAcl

		Update-GarmStatus -CallbackURL $CallbackURL -Message "configuring and starting runner"
		cd $runnerDir

		{{- if .UseJITConfig }}
		Update-GarmStatus -CallbackURL $CallbackURL -Message "downloading JIT credentials"
		wget -UseBasicParsing -Headers @{"Accept"="application/json"; "Authorization"="Bearer $Token"} -Uri $MetadataURL/credentials/runner -OutFile (Join-Path $runnerDir ".runner")
		wget -UseBasicParsing -Headers @{"Accept"="application/json"; "Authorization"="Bearer $Token"} -Uri $MetadataURL/credentials/credentials -OutFile (Join-Path $runnerDir ".credentials")

		Add-Type -AssemblyName System.Security
		$rsaData = (wget -UseBasicParsing -Headers @{"Accept"="application/json"; "Authorization"="Bearer $Token"} -Uri $MetadataURL/credentials/credentials_rsaparams)
		$encodedBytes = [System.Text.Encoding]::UTF8.GetBytes($rsaData)
		$protectedBytes = [Security.Cryptography.ProtectedData]::Protect( $encodedBytes, $null, [Security.Cryptography.DataProtectionScope]::LocalMachine )
		[System.IO.File]::WriteAllBytes((Join-Path $runnerDir ".credentials_rsaparams"), $protectedBytes)

		$serviceNameFile = (Join-Path $runnerDir ".service")
		wget -UseBasicParsing -Headers @{"Accept"="application/json"; "Authorization"="Bearer $Token"} -Uri $MetadataURL/system/service-name -OutFile $serviceNameFile

		Update-GarmStatus -CallbackURL $CallbackURL -Message "Creating system service"
		$SVC_NAME=(gc -raw $serviceNameFile)
		New-Service -Name "$SVC_NAME" -BinaryPathName "C:\actions-runner\bin\RunnerService.exe" -DisplayName "$SVC_NAME" -Description "GitHub Actions Runner ($SVC_NAME)" -StartupType Automatic -Credential $pscreds
		Start-Service "$SVC_NAME"
		Set-SystemInfo -CallbackURL $CallbackURL -RunnerDir $runnerDir -BearerToken $Token
		Update-GarmStatus -Message "runner successfully installed" -CallbackURL $CallbackURL -Status "idle" | Out-Null

		{{- else }}
		$GithubRegistrationToken = Start-ExecuteWithRetry -ScriptBlock {
			Invoke-WebRequest -UseBasicParsing -Headers @{"Accept"="application/json"; "Authorization"="Bearer $Token"} -Uri $MetadataURL/runner-registration-token/
		} -MaxRetryCount 5 -RetryInterval 5 -RetryMessage "Retrying download of GitHub registration token..."
		{{- if .GitHubRunnerGroup }}
		./config.cmd --unattended --url "{{ .RepoURL }}" --token $GithubRegistrationToken --runnergroup {{.GitHubRunnerGroup}} --name "{{ .RunnerName }}" --labels "{{ .RunnerLabels }}" --no-default-labels --ephemeral --runasservice --windowslogonaccount runner --windowslogonpassword "$userPasswd"
		{{- else}}
		./config.cmd --unattended --url "{{ .RepoURL }}" --token $GithubRegistrationToken --name "{{ .RunnerName }}" --labels "{{ .RunnerLabels }}" --no-default-labels --ephemeral --runasservice --windowslogonaccount runner --windowslogonpassword "$userPasswd"
		{{- end}}
		if ($LASTEXITCODE) {
			Throw "Failed to configure runner. Err code $LASTEXITCODE"
		}
		$agentInfoFile = Join-Path $runnerDir ".runner"
		$agentInfo = ConvertFrom-Json (gc -raw $agentInfoFile)
		Set-SystemInfo -CallbackURL $CallbackURL -RunnerDir $runnerDir -BearerToken $Token
		Invoke-GarmSuccess -CallbackURL $CallbackURL -Message "runner successfully installed" -AgentID $agentInfo.agentId
		{{- end }}
	} catch {
		Invoke-GarmFailure -CallbackURL $CallbackURL -Message $_
	}
}
Install-Runner
"
}

This is the same windows userdata template you can find here: https://github.com/cloudbase/garm-provider-common/blob/4163ff05a62f7ffa1b8a6814fe5eefa01debfa0a/cloudconfig/templates.go#L207

but with the runner user renamed to garmrunner. Feel free to edit the template.

Let me know if this makes things work. If it does, then it's probably because you already have the runner user in a custom image. If that's the case, we can add a check in the userdata script.

[rgl]

You mean the image set by garm-cli pool create --image MicrosoftWindowsServer:WindowsServer:2022-Datacenter:latest? If so, that's exactly the image I'm using.

[gabriel-samfira]

hah. Let me try out the azure provider with the config you posted. I'll ping back soon.

[gabriel-samfira]

You mean the image set by garm-cli pool create --image MicrosoftWindowsServer:WindowsServer:2022-Datacenter:latest? If so, that's exactly the image I'm using.

Would you mind trying the template I posted above anyway, while I try to reproduce on my side?

[gabriel-samfira]

ahh. I know what's happening. When creating a VM on Azure, we need to specify an admin username. We use the value from the common package.

I will create a PR for the Azure provider to change the default admin username and also add an extra specs field to customize it. Until it merges, you can use the template I posted above. It should avoid the error.

[rgl]

It now fails with the rgl-garm-window\runner is already a member of group Administrators._x000D__x000A_ error:

<S S="Error">rgl-garm-window\runner is already a member of group Administrators._x000D__x000A_</S>
    <S S="Error">At C:\run.ps1:333 char:3_x000D__x000A_</S>
    <S S="Error">+         Throw $Message_x000D__x000A_</S>
    <S S="Error">+         ~~~~~~~~~~~~~~_x000D__x000A_</S>
    <S S="Error">    + CategoryInfo          : OperationStopped: (rgl-garm-window...Administrators.:String) [], RuntimeException_x000D__x000A_</S>
    <S S="Error">    + FullyQualifiedErrorId : rgl-garm-window\runner is already a member of group Administrators._x000D__x000A_</S>
    <S S="Error"> _x000D__x000A_</S>

Its somewhat hard to debug this. To make things easier, I would:

1. drop the go templates altogether, and instead, use standalone .ps1 file(s) that can be tested separately, with proper arguments, instead of go template syntax, that would allow us to more easily inspect them and do static code analyses on them in the github actions workflow.
2. modify the powershell code to have a global trap that shows the line (and stack trace) where the error happened.
3. document how to login into these machines and how to put them in debug mode. maybe this is already document, and I've missed it.

[gabriel-samfira]

The error you got is my fault. I failed to properly edit this line:

Add-LocalGroupMember -Group $adminGrpName -Member runner

I am working on a branch to fix this. But it might take a couple of days. After that I will cut a release for the azure provider, and rebuild the garm container image. Until then, please use the previous stable release of the azure provider. That should still work fine.

We chose templates because it was the simplest way to leverage userdata that is available in all clouds. Using a static install script is less easy for Windows on most clouds, as not all clouds use cloudbase-init. So everyone implemented their own thing. On Amazon for example, we need to wrap the userdata in <powershell></powershell> tags. There is no easy way to write a static file and call it from the userdata.

Regarding the static ps1, you could do that in theory, even now, but you'd have to embed the ps1 as base64 into the userdata and create a wrapper around it to dump it to disk, then call it with parameters.

But if testability is the goal, we could render the final template based on some test context and analyze the resulting setup script.

Sorry for the headache! I'll try to fix this as soon as possible.

[rgl]

ah no worries! I can wait!

as for the script, I think its easier to troubleshoot when its a standalone script, because, one can simply login into the machine, and directly execute it.

making garm dump the final script for the user to see, is a nice to have, but if the script is already standalone in the repository, as one can simple go into the repository and get it. for me, the most important part, its on how easy is to figure out what is the problem while launching a runner.

[gabriel-samfira]

as for the script, I think its easier to troubleshoot when its a standalone script, because, one can simply login into the machine, and directly execute it.

to some extent. Once the script calls into GARM and sets a status of "idle" or "failed", the token used to interact with the API is invalidated and cannot be run again. This is a security measure to ensure that the userdata script can only ever fetch one runner registration token. Otherwise, once a runner is set up and a workflow starts running, it's trivial for potential untrusted code to inspect the userdata of the instance its running on, get the GARM token and use that to generate as many runner registration tokens as they wish. An attacker could then register their own runners in your repo.

So the point is that by the time workflows run, the userdata of the instance and any credentials contained within, become useless.

for me, the most important part, its on how easy is to figure out what is the problem while launching a runner.

We can definitely improve on the error reporting. If you do a garm-cli runner show <runner name>, do you see the error message? There is a try/catch that phones home with the error.

[rgl]

as for the script, I think its easier to troubleshoot when its a standalone script, because, one can simply login into the machine, and directly execute it.

to some extent. Once the script calls into GARM and sets a status of "idle" or "failed", the token used to interact with the API is invalidated and cannot be run again. This is a security measure to ensure that the userdata script can only ever fetch one runner registration token. Otherwise, once a runner is set up and a workflow starts running, it's trivial for potential untrusted code to inspect the userdata of the instance its running on, get the GARM token and use that to generate as many runner registration tokens as they wish. An attacker could then register their own runners in your repo.

ah, got it! glossing over many details, for a bit more, one would need to have a different token, or some way to start a runner in debug mode to receive a different kind of token. so, maybe too much trouble for this.

hummm the threat model of this system seems very interesting! is it documented?

So the point is that by the time workflows run, the userdata of the instance and any credentials contained within, become useless.

for me, the most important part, its on how easy is to figure out what is the problem while launching a runner.

We can definitely improve on the error reporting. If you do a garm-cli runner show <runner name>, do you see the error message? There is a try/catch that phones home with the error.

Oh, I did not realize there was a show command! Thanks for pointing it out! I was getting the error from the Azure Portal, at the VM script extension page.

This is what it returns when there is an error:

$ ./garm-cli runner show "$runner_name"
+-----------------+------------------------------------------------------------------------------------------+
| FIELD           | VALUE                                                                                    |
+-----------------+------------------------------------------------------------------------------------------+
| ID              | 0ccaff47-020b-4747-9803-0bb1bc81d48d                                                     |
| Created At      | 2025-07-30 18:39:46.171766407 +0000 UTC                                                  |
| Updated At      | 2025-07-30 18:42:16.437660538 +0000 UTC                                                  |
| Provider ID     | rgl-garm-windows-org-yQyfzOj5FVZ0                                                        |
| Name            | rgl-garm-windows-org-yQyfzOj5FVZ0                                                        |
| OS Type         | windows                                                                                  |
| OS Architecture | amd64                                                                                    |
| OS Name         | 2022-Datacenter                                                                          |
| OS Version      | latest                                                                                   |
| Status          | running                                                                                  |
| Runner Status   | failed                                                                                   |
| Pool ID         | 1d00dddf-1038-46b2-9d03-b5e2f0fb4faf                                                     |
| Status Updates  | 2025-07-30T18:42:16: rgl-garm-window\runner is already a member of group Administrators. |
+-----------------+------------------------------------------------------------------------------------------+

$ ./garm-cli runner show "$runner_name" --format json | jq
{
  "id": "0ccaff47-020b-4747-9803-0bb1bc81d48d",
  "provider_id": "rgl-garm-windows-org-yQyfzOj5FVZ0",
  "agent_id": 48,
  "name": "rgl-garm-windows-org-yQyfzOj5FVZ0",
  "os_type": "windows",
  "os_name": "2022-Datacenter",
  "os_version": "latest",
  "os_arch": "amd64",
  "status": "running",
  "runner_status": "failed",
  "pool_id": "1d00dddf-1038-46b2-9d03-b5e2f0fb4faf",
  "status_messages": [
    {
      "created_at": "2025-07-30T18:42:16.436901233Z",
      "message": "rgl-garm-window\\runner is already a member of group Administrators.",
      "event_type": "status",
      "event_level": "info"
    }
  ],
  "created_at": "2025-07-30T18:39:46.171766407Z",
  "updated_at": "2025-07-30T18:42:16.437660538Z"
}

Maybe that event_level should have been error or the word "ERROR" should be in the message. Or even have a "Global Error" kinda of error. Something that make it obvious there was an error (even thou the runner_status already says failed).

It also does not show a stack trace. But since this is generated from a template, maybe matching the stack trace lines from the template is not simple or even possible.

I also noticed that we cannot use the runner id in the garm-cli runner show command (the other calls like garm-cli pool update can use an id) instead we have to use the runner name.

Are these minor issues worthy of a GitHub Issue?

Ah, and modifying Add-LocalGroupMember -Group $adminGrpName -Member runner to use garmrunner made it work here! :-)

[gabriel-samfira]

hummm the threat model of this system seems very interesting! is it documented?

I've been meaning to write a design doc with why some things work the way they do. Hopefully I can find some time to do that in a way that won't put people to sleep.

Maybe that event_level should have been error or the word "ERROR" should be in the message. Or even have a "Global Error" kinda of error. Something that make it obvious there was an error (even thou the runner_status already says failed).

Yep. I always meant to use the events for more things and perhaps set proper levels. I've been looking at otel as an option instead of baking our own thing. I added status updates for runners to give some transparency, but trying out otel seemed like too much for the time I had available. But we can certainly set proper event log levels.

I also noticed that we cannot use the runner id in the garm-cli runner show command (the other calls like garm-cli pool update can use an id) instead we have to use the runner name.

The runner names are unique. The ID was used as the primary key because we used the same base model for all database models when I first wrote GARM a few years ago. The goal now is to allow friendly names along side IDs. The main branch for example allows you to use repo/org/enterprise names instead of IDs when creating pools. But to keep things consistent, we should allow referencing runners by both names and IDs.

Are these minor issues worthy of a GitHub Issue?

We can use this issue to track them.

Ah, and modifying Add-LocalGroupMember -Group $adminGrpName -Member runner to use garmrunner made it work here! :-)

That's awesome! I'm hoping to fix this in garm-provider-common and then update the azure provider soon.

[gabriel-samfira]

@rgl @chickenkiller

Would you mind trying the template from: cloudbase/garm-provider-common#49 ?

you can set it in extra specs. I tested it on my side and it seems to work well, but I would like for someone else to validate as well. If it works, I'll merge it and update the azure provider to use it.

[chickenkiller]

@rgl @chickenkiller

Would you mind trying the template from: cloudbase/garm-provider-common#49 ?

Hello @gabriel-samfira I confirm that it works:

+-----------------+------------------------------------------------------------------------------------------------------+
| FIELD           | VALUE                                                                                                |
+-----------------+------------------------------------------------------------------------------------------------------+
| ID              | a5be8138-c9a7-47f7-96b5-fd4dc0eaf7d1                                                                 |
| Created At      | 2025-08-06 06:26:25.951794484 +0000 UTC                                                              |
| Updated At      | 2025-08-06 06:29:08.526938997 +0000 UTC                                                              |
| Provider ID     | garmdev-ncM8br3Bck4W                                                                                 |
| Name            | garmdev-ncM8br3Bck4W                                                                                 |
| OS Type         | windows                                                                                              |
| OS Architecture | amd64                                                                                                |
| OS Name         | Microsoft Windows Server 2022 Datacenter Azure Edition                                               |
| OS Version      | 10.0.20348                                                                                           |
| Status          | running                                                                                              |
| Runner Status   | idle                                                                                                 |
| Pool ID         | 9e6e5227-3f02-4333-9f4c-fcc65c8ea33a                                                                 |
| Status Updates  | 2025-08-06T06:28:52: downloading tools from https://github.mycompany/_services/pipeline              |
|                 | s/_apis/distributedtask/packagedownload/agent/win-x64/2.321.0                                        |
|                 | 2025-08-06T06:28:53: extracting runner                                                               |
|                 | 2025-08-06T06:28:55: configuring and starting runner                                                 |
|                 | 2025-08-06T06:28:55: downloading JIT credentials                                                     |
|                 | 2025-08-06T06:28:55: Creating system service                                                         |
|                 | 2025-08-06T06:29:08: runner successfully installed                                                   |
+-----------------+------------------------------------------------------------------------------------------------------+