Enhancing Azure Arc Onboarding with a Script Modification
Azure Arc simplifies hybrid and multi-cloud management by enabling you to extend Azure's capabilities to your on-premises servers and non-Azure environments. It empowers organizations to manage infrastructure, security, and compliance with consistency across diverse ecosystems. One practical approach for onboarding multiple domain-joined machines to Azure Arc is through Group Policy, utilizing a PowerShell script—a solution detailed in Microsoft's guide "Connect machines at scale using Group Policy".
However, a challenge arises when domain-joined machines were previously connected to an Azure tenant but can no longer authenticate due to a removed or invalidated tenant. In such cases, the original PowerShell script provided by Microsoft may fail as it only accounts for two scenarios:
- New install of the agent.
- Agent is already installed and successfully connected to a tenant.
In my case, my home lab VMs were connected to my previous tenant which got cratered due to Microsoft's aggressive Secure Future Initiative (SFI) where basically all employees who had a tenant for learning, training, testing, etc. had to start fresh with a new tenant in a fiercely managed environment. Now I have to effectively switch all my lab arc machines to my new tenant. There might be other approaches to accomplish this change but I wanted to leverage GPO and this existing solution (at the link above) came really close. To address this limitation, I tweaked the script slightly to resolve these connectivity issues and ensure successful onboarding of the Arc agent to the new Azure tenant.
...a challenge arises when domain-joined machines were previously connected to an Azure tenant but can no longer authenticate due to a removed or invalidated tenant.
- Nerd (anonymous)
EnableAzureArc.ps1 (modified)
You'll see in the comparison screenshot below that I added some error handling logic in only one function to account for the scenario where the agent already exists but authentication fails. The script will attempt to connect with the current tenant and service principal (created with the DeployGPO.ps1 script).
# Copyright (c) Microsoft Corporation.
# Licensed under the MIT License.
<#
.DESCRIPTION
This Script is meant to be in a network share and onboards a server in Azure Arc
using a Service Principal:
https://docs.microsoft.com/en-us/azure/azure-arc/servers/onboard-service-principal#create-a-service-principal-for-onboarding-at-scale
It makes the following validation checks before the onboarding:
- Checks if the machine is an Azure VM or a Non Azure Machine
- Checks Framework Version
- Checks PowerShell Version
If the server doesn't pass the requirements, all the information from the server: OS, Framework version,
PowerShell version, VM type ... is stored in a network share for further analisys.
If the server pass the requirements, the script checks if the Azure Hybrid Instance Metadata Service is already installed
If not, the script:
- Install the Connected Machine agent on the machine
- Connects the server to Azure Arc using a Service Principal
- Tags Azure Arc server with a given Tag
- Any Connection error is logged and the Agent code get: https://docs.microsoft.com/en-us/azure/azure-arc/servers/troubleshoot-agent-onboard#agent-error-codes
In positive case, the script:
- Checks azcmagent.exe version and updates the agent if a new version is found in the network folder
- Checks its connection status
- In case the server is disconnected it logs the last errors from the azcmagent.exe Agent on the shared folder
.PARAMETER ReportServerFQDN
FQDN of the Server that will act as report Server (and source files)
.PARAMETER AssessOnly
Switch parameter that makes script work in Assess mode.
No machines will be onboarded in Azure Arc.
Machines will only report if their prerequesites are met or not to the report share
.EXAMPLE
This example onboards machines in Azure Arc
.\EnableAzureArc.ps1 -ArcRemoteShare AzureArcOnBoard
.EXAMPLE
This example assesses machines Azure Arc prerequisites and sends the info to the report share
.\EnableAzureArc.ps1 -ArcRemoteShare AzureArcOnBoard -AssessOnly
#>
Param (
[Parameter(Mandatory = $true)]
[System.String]$ArcRemoteShare,
[Parameter(Mandatory = $true)]
[System.String]$ReportServerFQDN,
[switch]$AssessOnly
)
#Calculate Logging path
$LoggingNetworkPath = "$((Join-Path -Path "\\$ReportServerFQDN" -ChildPath $ArcRemoteShare) -replace "\\$")" + "\AzureArcLogging"
#Calculate network full path
$SourceFilesFullPath = "$((Join-Path -Path "\\$ReportServerFQDN" -ChildPath $ArcRemoteShare) -replace "\\$")" + "\AzureArcDeploy"
$arcInfo = Get-Content (Join-Path $SourceFilesFullPath "ArcInfo.json") | ConvertFrom-Json
###########################################################################################################
# Add the service principal application ID and more data here:
$servicePrincipalClientId = $arcInfo.ServicePrincipalClientId
$tenantid = $arcInfo.TenantId
$subscriptionid = $arcInfo.SubscriptionId
$ResourceGroup = $arcInfo.ResourceGroup
$location = $arcInfo.Location
$PrivateLinkScopeId = $arcInfo.PrivateLinkScopeId
$AgentProxy = $arcInfo.AgentProxy
$tags = @{ # Tags to be added to the Arc servers
DeployedBy = "GPO"
}
if($arcInfo.Tags){
$arcInfo.Tags.psobject.properties | Foreach { $tags[$_.Name] = $_.Value }
}
$workfolder = "$env:SystemDrive\temp"
$logpath = "$workfolder\AzureArcOnboarding.log" #Local log file
###########################################################################################################
#region Functions and classes Definition
Function Get-ArcAgentstatus {
Param (
[Switch]$loglocally,
[ValidateSet("info", "error")]
[System.String[]]$logtype
)
$agentstatus = (& "$($env:ProgramW6432)\AzureConnectedMachineAgent\azcmagent.exe" show -j) | ConvertFrom-Json
if ($loglocally) {
# Logs the status in the AzureArcAgentOnboarding.log
switch ($logtype) {
"info" {
$agentstatus | Get-Member -MemberType NoteProperty -Name "*HeartBeat" | ForEach-Object {
Write-Log -msg "$($_.Name) : $($agentstatus.$($_.Name))" -msgtype INFO
}
}
"error" {
$agentstatus | Get-Member -MemberType NoteProperty -Name "*Error*" | ForEach-Object {
Write-Log -msg "$($_.Name) : $($agentstatus.$($_.Name))" -msgtype ERROR
}
}
}
}
$agentstatushash = [ordered]@{}
$agentstatus.psobject.properties | Sort-Object -Property Name | ForEach-Object { $agentstatushash[$_.Name] = $_.Value } # Converts to Hashtable
return $agentstatushash
}
Function Get-ArcAgentErrorLogs {
[cmdletbinding()]
Param(
[datetime]$since
)
$script:azcmagentErrors = Get-Content "$env:Programdata\AzureConnectedMachineAgent\Log\azcmagent.log" | Select-String "level=fatal" | Where-Object { [datetime](($_ -split "\s")[0] -replace "time=" -replace '"') -gt $since }
$HimdsErrors = Get-Content "$env:Programdata\AzureConnectedMachineAgent\Log\himds.log" | Select-String "error" |
Where-Object { [datetime](($_ -split "\s")[0] -replace "time=" -replace '"') -gt $since }
foreach ($azcmagentError in $script:azcmagentErrors) {
Write-Log -msg $azcmagentError -msgtype ERROR
}
foreach ($HimdsError in $HimdsErrors) {
Write-Log -msg $HimdsError -msgtype ERROR
}
}
Function Install-ArcAgent {
# Install the package
if (-not (Test-Path "$SourceFilesFullPath\AzureConnectedMachineAgent.msi" -ErrorAction SilentlyContinue)) {
Write-Log -msg "AzureConnectedMachineAgent.msi file not found in the network folder. Exiting... " -msgtype ERROR
exit
}
# If no local msi found, downloads it from the network share
if (-not (Test-Path "$env:LOCALAPPDATA\AzureConnectedMachineAgent.msi" -ErrorAction SilentlyContinue)) {
Copy-Item -Path "$SourceFilesFullPath\AzureConnectedMachineAgent.msi" -Destination "$env:LOCALAPPDATA" -Force
}
Write-Log -msg "Installing Azure Connected Machine Agent" -msgtype INFO
Set-Location $workfolder
$exitCode = (Start-Process -FilePath msiexec.exe -ArgumentList @("/i", "$env:LOCALAPPDATA\AzureConnectedMachineAgent.msi" , "/l*v", "Azcmagentinstallationlog.txt", "/qn") -Wait -Passthru).ExitCode
$message = (net helpmsg $exitCode)
if ($exitCode -ne 0) {
Write-Log -msg "Installation failed: $message. See Azcmagentinstallationlog.txt for additional details" -msgtype ERROR
throw $message
}
else {
Write-Log -msg "Azure Connected Machine Agent installed. $message" -msgtype INFO
}
}
Function Get-MsiVersion {
Param (
[IO.FileInfo]$path
)
$windowsInstaller = New-Object -ComObject WindowsInstaller.Installer
$database = $windowsInstaller.GetType().InvokeMember(
"OpenDatabase", "InvokeMethod", $Null,
$windowsInstaller, @($path.FullName, 0)
)
$query = "SELECT Value FROM Property WHERE Property = 'ProductVersion'"
$View = $database.GetType().InvokeMember(
"OpenView", "InvokeMethod", $Null, $database, ($query)
)
$View.GetType().InvokeMember("Execute", "InvokeMethod", $Null, $View, $Null)
$record = $View.GetType().InvokeMember( "Fetch", "InvokeMethod", $Null, $View, $Null )
$version = ($record.GetType().InvokeMember( "StringData", "GetProperty", $Null, $record, 1 ))
return $version
}
Function Update-ArcAgentVersion {
Write-Log -msg "Checking Local Agent version for updates ..." -msgtype INFO
#Checks Current Agent Version
[Version]$LocalAgentVersion = (Get-ArcAgentstatus).Agentversion
#Checks network share version
[Version]$NetworkShareVersion = (Get-MsiVersion -path "$SourceFilesFullPath\AzureConnectedMachineAgent.msi")[1]
#Compare versions
if ($LocalAgentVersion -lt $NetworkShareVersion) {
# New Agent Version Found
Write-Log -msg "New Agent version found in network share folder: $($NetworkShareVersion.ToString()) , local version is $($LocalAgentVersion.ToString()). Executing update ..." -msgtype WARNING
# Download the package
Copy-Item -Path "$SourceFilesFullPath\AzureConnectedMachineAgent.msi" -Destination "$env:LOCALAPPDATA" -Force
#Install the package
Update-ArcAgent
#Checks new Version
[Version]$LocalAgentVersion = (Get-ArcAgentstatus).Agentversion
Write-Log -msg "Azure Connected Machine Agent Version is now $($LocalAgentVersion.ToString())" -msgtype INFO
}
else {
#Latest Version Found
Write-Log -msg "Machine has latest available version of the agent: $($LocalAgentVersion.ToString())" -msgtype INFO
}
}
Function Update-ArcAgent {
# Update Agent
Write-Log -msg "Updating Azure Connected Machine Agent" -msgtype INFO
Set-Location $workfolder
$exitCode = (Start-Process -FilePath msiexec.exe -ArgumentList @("/i", "$env:LOCALAPPDATA\AzureConnectedMachineAgent.msi" , "/l*v", "Azcmagentupdatesetup.txt", "/qn") -Wait -Passthru).ExitCode
$message = (net helpmsg $exitCode)
if ($exitCode -ne 0) {
Write-Log -msg "Update failed: $message. See Azcmagentupdatesetup.txt for additional details" -msgtype ERROR
throw $message
}
else {
Write-Log -msg "Azure Connected Machine Agent updated. $message" -msgtype INFO
}
}
Function Get-ServicePrincipalSecret {
try {
Copy-Item (Join-Path $SourceFilesFullPath "AzureArcDeployment.psm1") $workfolder -Force
Import-Module (Join-Path $workfolder "AzureArcDeployment.psm1")
$encryptedSecret = Get-Content (Join-Path $SourceFilesFullPath encryptedServicePrincipalSecret)
$sps = [DpapiNgUtil]::UnprotectBase64($encryptedSecret)
Remove-Item (Join-Path $workfolder "AzureArcDeployment.psm1") -Force
}
catch {
Write-Log -msg "Could not fetch service principal secret: $($_.Exception)" -msgtype ERROR
return $false
}
return $sps
}
Function Add-SiteTag {
$adsite = (& "$env:windir\system32\nltest.exe" /dsgetsite)[0]
if ($LastExitCode -eq 0) {
Write-Log -msg "Tag Site:$adsite added to azure connected machine tags" -msgtype INFO
$script:tags["Site"] = $adsite
}
else {
Write-Log -msg "Could not determine machine's AD Site" -msgtype WARNING
$script:tags["Site"] = "Unknown"
}
}
Function Connect-ArcAgent {
# Add AD site as a tag
Add-SiteTag
# Run connect command
Write-Log -msg "Trying to Connect Azure Connected Machine Agent ..." -msgtype INFO
$FinalTag = ($tags.GetEnumerator() | ForEach-Object -Process { "$($_.key)" + "=" + "'$($_.value)'" }) -join ","
$sps = Get-ServicePrincipalSecret
# if agent proxy is specified
if ($AgentProxy) {
$Proxyconf = & "$env:ProgramW6432\AzureConnectedMachineAgent\azcmagent.exe" config set proxy.url $AgentProxy #Proxy Configured
}
# if private link scope is specified
if ($PrivateLinkScopeId) {
if ($AgentProxy -ne "") {
& "$env:ProgramW6432\AzureConnectedMachineAgent\azcmagent.exe" config set proxy.bypass "Arc" #Bypass proxy for Arc services (his.arc.azure.com, guestconfiguration.azure.com, guestnotificationservice.azure.com, servicebus.windows.net)
}
$ConnectionOutput = & "$env:ProgramW6432\AzureConnectedMachineAgent\azcmagent.exe" connect --resource-name $env:computername --service-principal-id $servicePrincipalClientId --service-principal-secret $sps --resource-group $ResourceGroup --tenant-id $tenantid --location $location --subscription-id $subscriptionid --cloud AzureCloud --tags $FinalTag --private-link-scope $PrivateLinkScopeId --correlation-id "478b97c2-9310-465a-87df-f21e66c2b248"
}
else {
$ConnectionOutput = & "$env:ProgramW6432\AzureConnectedMachineAgent\azcmagent.exe" connect --resource-name $env:computername --service-principal-id $servicePrincipalClientId --service-principal-secret $sps --resource-group $ResourceGroup --tenant-id $tenantid --location $location --subscription-id $subscriptionid --cloud AzureCloud --tags $FinalTag --correlation-id "478b97c2-9310-465a-87df-f21e66c2b248"
}
if ($LastExitCode -eq 0) {
Write-Log -msg "Agent connected successfully!. To view your onboarded server(s), navigate to https://ms.portal.azure.com/#blade/Microsoft_Azure_HybridCompute/AzureArcCenterBlade/servers" -msgtype INFO
return $True
}
else {
#check for any errors in Agent connection
Write-Log -msg "Agent Connection was unsuccessful. Waiting for logs to be generated..." -msgtype ERROR
Start-Job -ScriptBlock {
$script:Agentcode = $null
do {
$script:Agentcode = Get-Content "$env:ProgramData\AzureConnectedMachineAgent\Log\azcmagent.log"-Tail 50 | Select-String 'AZCM\d*:[\s\w]*' | ForEach-Object { $_.matches } | Select-Object -Last 1 -ExpandProperty value
}
Until ($null -ne $script:Agentcode)
Write-Log -msg "Agent Code: $script:Agentcode" -msgtype ERROR
Write-Log -msg "Check AZCM Agent codes here: https://docs.microsoft.com/en-us/azure/azure-arc/servers/troubleshoot-agent-onboard#agent-error-codes" -msgtype INFO
} | Wait-Job -Timeout 30
return $false
}
}
Function Repair-ArcAgentConnection {
#TODO:
#The Machine could be moved, it has to maintaing the same config:
#$RegistrationInfo = Get-Registrationinfo
#$ConnectionOuput = & "$env:ProgramW6432\AzureConnectedMachineAgent\azcmagent.exe" connect --service-principal-id $servicePrincipalClientId --service-principal-secret $RegistrationInfo --resource-group $Agentconfig.resourceGroup --tenant-id $Agentconfig.tenantId --location $Agentconfig.location --subscription-id $Agentconfig.subscriptionId --cloud $Agentconfig.Cloud --tags $FinalTag --correlation-id $Agentconfig.correlationId
}
Function Send-ArcData {
[cmdletbinding()]
Param(
[Parameter(Mandatory = $true)]
[psobject]$Data,
[Parameter(Mandatory = $true)]
[System.String]$Path
)
Write-Log -msg "Sending information to central Shared folder ..." -msgtype INFO
$ParentPath = Split-Path -Path $path -Parent
if ($? -eq $false) { Write-Log -msg "$($error[0].Exception)" -msgtype ERROR }
if (-not(Test-Path ($ParentPath))) {
New-Item -Path $ParentPath -ItemType Directory -Force
if ($? -eq $false) { Write-Log -msg "$($error[0].Exception)" -msgtype ERROR }
}
$Data | Export-Clixml -Path $Path -Force
if ($? -eq $false) { Write-Log -msg "$($error[0].Exception)" -msgtype ERROR }
}
Function Test-ArcAgentConnection {
#Check if the Azure Connected Machine Agent is connected
try {
Write-Log "Will check http://localhost:40342/agentstatus ..." -msgtype INFO;
$Agentresponse = Invoke-WebRequest -Uri "http://localhost:40342/agentstatus" -UseBasicParsing -ErrorAction Stop
If ($Agentresponse.Content -match 'Bearer token validation failed' ) {
throw "'Bearer token validation failed'."
}
If (($Agentresponse.Content | ConvertFrom-Json).status -ne 'Connected') {
throw "Not currently connected."
}
}
catch {
Write-Log "There was an error when trying to get agent status: $($_.Exception)" -msgtype ERROR;
Write-Log "Will try to connect with new/current tenant settings..." -msgtype WARNING;
# Attemp new/current connections settings.
try {
Connect-ArcAgent
$Agentresponse = Invoke-WebRequest -Uri "http://localhost:40342/agentstatus" -UseBasicParsing -ErrorAction Stop
}
Catch {
Write-Log "There was an error when trying to connect with new/current tenant settings: $($_.Exception)" -msgtype ERROR; throw $_.Exception
}
}
$azcmagentstatus = $Agentresponse | ConvertFrom-Json
if ($azcmagentstatus.status -ne "Connected") {
return $false
}
else {
return $true
}
}
Function Test-ArcService {
#Check if the Azure Hybrid Instance Metadata Service is already installed
try { Get-Service himds -ErrorAction Stop }
catch {
Write-Log -msg "No Hybrid Instance Metadate Service installed" -msgtype ERROR
return $false
}
Write-Log -msg "Machine has the Hybrid Instance Metadata Service already installed ..." -msgtype INFO
return $true
}
Function Write-Log {
Param (
[System.String]$msg,
[ValidateSet("INFO", "ERROR", "WARNING")]
[System.String]$msgtype,
[switch]$Force
)
if ($PSBoundParameters.ContainsKey("Force")) {
Write-Output -InputObject "$(Get-Date -Format ("[yyyy-MM-dd][HH:mm:ss]")) $msgtype $msg" | Out-File $logpath
}
else {
Write-Output -InputObject "$(Get-Date -Format ("[yyyy-MM-dd][HH:mm:ss]")) $msgtype $msg" | Out-File $logpath -Append
}
}
#endregion
# MAIN
if (-not (Test-Path $workfolder))
{ New-Item -Path $workfolder -Force -ItemType Directory | Out-Null }
#Reduces by 1/4 the log file if excedees of 10mb
if ((Get-Item $logpath -ErrorAction SilentlyContinue).Length -gt 10mb) {
$content = Get-Content $logpath
$content[[int]($content.Length / 4)..($content.length - 1)] | Out-File $logpath -Force
}
Write-Log -msg "=========================================" -msgtype INFO
Write-Log -msg "Starting Azure Arc Onboarding process ..." -msgtype INFO
Write-Log -msg "Sources full path: $SourceFilesFullPath" -msgtype INFO
Write-Log -msg "Logging network full path: $LoggingNetworkPath" -msgtype INFO
$hash = @{
Computer = $env:COMPUTERNAME
OSVersion = (Get-WmiObject -Class win32_Operatingsystem).Caption
FrameworkVersion = ""
PowershellVersion = ($PSVersionTable.PSVersion.ToString()).substring(0, 3)
AzureVM = $false
ArcCompatible = $true
AgentStatus = ""
AgentLastHeartbeat = ""
AgentErrorCode = ""
AgentErrorTimestamp = (New-Object -TypeName datetime -ArgumentList ($null))
AgentErrorDetails = ""
httpsProxy = ""
}
$ArcOnboardingData = New-Object -TypeName PSobject -Property $hash
# Check Framework version
$FrameworkRegistry = "HKLM:\SOFTWARE\Microsoft\NET Framework Setup\NDP\v4\Client"
try {
Test-Path -Path $FrameworkRegistry -ErrorAction Stop | Out-Null
[version]$FWVersion = Get-ItemProperty -Path $FrameworkRegistry -Name Version -ErrorAction Stop | Select-Object -ExpandProperty Version
$ArcOnboardingData.FrameworkVersion = $FWVersion.ToString()
}
catch {
Write-Log -msg "Framework version is 3.5 or less and it's unsupported" -msgtype ERROR
$ArcOnboardingData.FrameworkVersion = "3.5 or less"
$ArcOnboardingData.ArcCompatible = $false
}
if (($FWVersion.major -lt 4) -or (($FWVersion.Major -eq 4) -and ($FWVersion.Minor -lt 6))) {
Write-Log -msg "Framework version $($FWVersion.ToString()) is unsupported" -msgtype ERROR
$ArcOnboardingData.ArcCompatible = $false
}
else {
Write-Log -msg "Machine has Framework version $($FWVersion.ToString()), this is supported" -msgtype INFO
}
#Check PowerShell Version (Powershell 4 is required)
if ($PSVersionTable.PSVersion.Major -lt 4) {
Write-Log -msg "Machine has Powershell version $($PSVersionTable.PSVersion.Major), minimum version required is PowerShell v4." -msgtype ERROR
$ArcOnboardingData.ArcCompatible = $false
}
else {
Write-Log -msg "Machine has PowerShell version version $($PSVersionTable.PSVersion.Major), this is supported" -msgtype INFO
}
#Check if it's an Azure VM
try {
$TestAzuremachine = Invoke-RestMethod -Headers @{"Metadata" = "true" } `
-Method GET -Proxy $Null -Uri "http://169.254.169.254/metadata/instance?api-version=2020-09-01"`
-TimeoutSec 3 -ErrorAction SilentlyContinue | ConvertTo-Json -Depth 64
}
catch {}
If ($Null -ne $TestAzuremachine) {
Write-Log -msg "Machine is an Azure VM, it won't be onboarded in Azure Arc" -msgtype ERROR
$ArcOnboardingData.AzureVM = $true
$ArcOnboardingData.ArcCompatible = $false
Write-Log -msg "Exiting Onboarding Process" -msgtype INFO
exit
}
else {
Write-Log -msg "Machine is not an Azure VM. Continuing the onboarding process" -msgtype INFO
$ArcOnboardingData.AzureVM = $false
}
#In case the onboarding is in AssessOnly mode, the onboarding process posts the data and exits
if ($PSBoundParameters.ContainsKey('AssessOnly')) {
Write-Log -msg "Arc GPO Onboarding is in AssessOnly mode. Remove the -AssessOnly parameter from the scheduled task in the GPO if you want the machines to be onboarded in Azure ARC." -msgtype WARNING
Send-ArcData -Data $ArcOnboardingData -Path "$LoggingNetworkPath\$($env:COMPUTERNAME).xml"
Write-Log -msg "End of the Azure Arc Onboarding process..." -msgtype INFO
exit
}
#Post to share if Machine has dependencies to solve
if (($ArcOnboardingData.AzureVM -eq $false) -and ($ArcOnboardingData.ArcCompatible -eq $false)) {
Write-Log -msg "Machine doesn't meet the minimum requirements for Azure Arc: Windows PowerShell 4 and NET Framework 4.6, or it is an Azure VM." -msgtype ERROR
Send-ArcData -Data $ArcOnboardingData -Path "$LoggingNetworkPath\$($env:COMPUTERNAME).xml"
Write-Log -msg "End of the Azure Arc Onboarding process..." -msgtype INFO
exit
}
#region Onboarding Process
#Checks Arc Service
if ((Test-ArcService) -eq $false) {
Install-ArcAgent
$StartConnection = Get-Date
if ((Connect-ArcAgent) -eq $false) {
Get-ArcAgentErrorLogs -since $StartConnection
Write-Log -msg "End of the Azure Arc Onboarding process." -msgtype INFO
exit
}
}
else {
# the Azure Hybrid Instance Metadata Service is already installed
#Ensures server has the latest Agent Version
Update-ArcAgentVersion
}
#Checks Agent Connectivity
if ((Test-ArcAgentConnection) -eq $false) {
#Log info locally
Write-Log -msg "Azure Connected Machine Agent is not connected ..." -msgtype ERROR
Get-ArcAgentErrorLogs -since (Get-Date).AddMinutes(-7)
$AgentProxyConfigured = (Get-ArcAgentstatus).httpsProxy
if ("" -eq $AgentProxyConfigured) {
Write-Log -msg "Machine has no proxy configured" -msgtype INFO
}
else { Write-Log -msg "Machine has the following proxy configured: $AgentProxyConfigured" -msgtype INFO }
if (-not (Test-Path "$env:Programdata\AzureConnectedMachineAgent\Config\agentconfig.json" )) {
Write-Log -msg "This machine has never been connected to Azure Arc, retrying one more time ..." -msgtype ERROR
$StartConnection = Get-Date
if ((Connect-ArcAgent) -eq $false) {
Get-ArcAgentErrorLogs -since $StartConnection
}
else {
# Machine connected successfuly
Write-Log -msg "End of the Azure Arc Onboarding process." -msgtype INFO
exit
}
}
#Prepare Information
$ArcAgentInfo = Get-ArcAgentstatus -logtype "error", "info" -loglocally # The status is also logged locally
$ArcOnboardingData.AgentStatus = $ArcAgentInfo.status
$ArcOnboardingData.AgentErrorCode = $script:AgentCode
$ArcOnboardingData.AgentLastHeartbeat = $ArcAgentInfo.lastHeartbeat
$ArcOnboardingData.AgentErrorTimestamp = [datetime]([regex]::match(($script:azcmagentErrors | Select-Object -Last 1 ), '^time="([\d\w\W]*)"\s').groups[1].value)
$ArcOnboardingData.AgentErrorDetails = [regex]::match(($script:azcmagentErrors | Select-Object -Last 1 ), 'msg="[\w\W\s]*').Groups[0].Value
$ArcOnboardingData.httpsProxy = $ArcAgentInfo.httpsProxy
#Send information to Share Folder
Send-ArcData -Data $ArcOnboardingData -Path "$LoggingNetworkPath\NotConnected\$($env:COMPUTERNAME).NotConnected.xml"
}
else {
Get-ArcAgentstatus -logtype "info" -loglocally
Write-Log -msg "Azure Connected Machine Agent is already connected." -msgtype INFO
}
Write-Log -msg "End of the Azure Arc Onboarding process." -msgtype INFO
#endregion
Once everything is in place (GPO, file share, necessary files, etc.). Run a GPO update to trigger the script.
gpupdate /force
I'll not be providing a download/file. Copy and paste. Enjoy!