From 0e7cb5ab59e814fd917b6b1cfa405c4ff24533ae Mon Sep 17 00:00:00 2001 From: Qingchuan Hao Date: Thu, 11 Apr 2024 08:55:47 +0000 Subject: [PATCH 01/13] update window cse to install credental provider --- staging/cse/windows/configfunc.ps1 | 71 ++++++++++++++++++++++++ staging/cse/windows/configfunc.tests.ps1 | 69 +++++++++++++++++++++++ 2 files changed, 140 insertions(+) diff --git a/staging/cse/windows/configfunc.ps1 b/staging/cse/windows/configfunc.ps1 index 717c54fb03c..131f1056224 100644 --- a/staging/cse/windows/configfunc.ps1 +++ b/staging/cse/windows/configfunc.ps1 @@ -342,6 +342,77 @@ function Install-OpenSSH { Write-Log "OpenSSH installed and configured successfully" } +function Config-CredentialProvider { + Param( + [Parameter(Mandatory = $false)][string] + $CustomCloudContainerRegistryDNSSuffix + ) + + $CredentialProviderConfPATH = [Io.path]::Combine("$global:KubeDir", "credential-provider-config.yaml") + + Write-Log "Configuring kubelet credential provider" + $azureConfigFile = [io.path]::Combine($global:KubeDir, "azure.json") + + $credentialProviderConfig = @" +apiVersion: kubelet.config.k8s.io/v1 +kind: CredentialProviderConfig +providers: + - name: acr-credential-provider + matchImages: + - "*.azurecr.io" + - "*.azurecr.cn" + - "*.azurecr.de" + - "*.azurecr.us" +"@ + if ($CustomCloudContainerRegistryDNSSuffix) { + $credentialProviderConfig += @" + + - "*$CustomCloudContainerRegistryDNSSuffix" +"@ + } + + $credentialProviderConfig+=@" + + defaultCacheDuration: "10m" + apiVersion: credentialprovider.kubelet.k8s.io/v1 + args: + - $azureConfigFile +"@ + $credentialProviderConfig | Out-File -encoding ASCII -filepath "$CredentialProviderConfPATH" +} + +function Install-CredentialProvider { + Param( + [Parameter(Mandatory = $false)][string] + $CustomCloudContainerRegistryDNSSuffix + ) + Logs-To-Event -TaskName "AKS.WindowsCSE.Install-CredentialProvider" -TaskMessage "Start to install credential provider" + + $KubeletConfigArgsStr=$global:KubeletConfigArgs -join " " + # Starting from Kubernetes 1.30, out of tree credential provider is enabled as a must. Otherwise, related kubelet flags will be set. + if ($KubeletConfigArgsStr -Like "*image-credential-provider-config*" -And $KubeletConfigArgsStr -Like "*image-credential-provider-bin-dir*") { + Write-Log "Credential provider is enabled" + + Write-Log "Create credential provider configuration file" + Config-CredentialProvider -CustomCloudContainerRegistryDNSSuffix $CustomCloudContainerRegistryDNSSuffix + + $CredentialProviderBinDir = "c:\var\lib\kubelet\credential-provider" + Write-Log "Download credential provider binary from $global:CredentialProviderURL to $CredentialProviderBinDir" + $tempDir = New-TemporaryDirectory + $credentialproviderbinaryPackage = "$tempDir\credentialprovider.tar.gz" + DownloadFileOverHttp -Url $global:CredentialProviderURL -DestinationPath $credentialproviderbinaryPackage -ExitCode $global:WINDOWS_CSE_ERROR_DOWNLOAD_CREDEDNTIAL_PROVIDER + tar -xzf $credentialproviderbinaryPackage -C $tempDir + Create-Directory -FullPath $CredentialProviderBinDir + cp "$tempDir\azure-acr-credential-provider.exe" "$CredentialProviderBinDir\acr-credential-provider.exe" + # acr-credential-provider.exe cannot be found by kubelet through provider name before the fix https://github.com/kubernetes/kubernetes/pull/120291 + # so we copy the exe file to acr-credential-provider to make all 1.29 release work. + cp "$CredentialProviderBinDir\acr-credential-provider.exe" "$CredentialProviderBinDir\acr-credential-provider" + del $tempDir -Recurse + } else { + Write-Log "Credential provider is not enabled" + } +} + function New-CsiProxyService { Param( [Parameter(Mandatory = $true)][string] diff --git a/staging/cse/windows/configfunc.tests.ps1 b/staging/cse/windows/configfunc.tests.ps1 index 2b66889d88c..1904fa2b6b8 100644 --- a/staging/cse/windows/configfunc.tests.ps1 +++ b/staging/cse/windows/configfunc.tests.ps1 @@ -104,4 +104,73 @@ Describe 'Resize-OSDrive' { Assert-MockCalled -CommandName "Set-ExitCode" -Exactly -Times 1 -ParameterFilter { $ExitCode -eq $global:WINDOWS_CSE_ERROR_RESIZE_OS_DRIVE } } } +} + +Describe 'Config-CredentialProvider' { + BeforeEach { + $global:KubeDir = "$PSScriptRoot" + $CredentialProviderConfPATH=[Io.path]::Combine("$global:KubeDir", "credential-provider-config.yaml") + } + + AfterEach { + Remove-Item -Path $CredentialProviderConfPATH + } + + Context 'CustomCloudContainerRegistryDNSSuffix is empty' { + It "should match the expected config file content" { + $expectedCredentialProviderConfig = @" +apiVersion: kubelet.config.k8s.io/v1 +kind: CredentialProviderConfig +providers: + - name: acr-credential-provider + matchImages: + - "*.azurecr.io" + - "*.azurecr.cn" + - "*.azurecr.de" + - "*.azurecr.us" + defaultCacheDuration: "10m" + apiVersion: credentialprovider.kubelet.k8s.io/v1 + args: + - $global:KubeDir\azure.json + + +"@ + Config-CredentialProvider -CustomCloudContainerRegistryDNSSuffix "" + $acutalCredentialProviderConfigStr = Get-Content $CredentialProviderConfPATH -Raw | Out-String + $acutalCredentialProviderConfig = @" +$acutalCredentialProviderConfigStr +"@ + $diffence = Compare-Object $acutalCredentialProviderConfig $expectedCredentialProviderConfig + $diffence | Should -Be $null + } + } + Context 'CustomCloudContainerRegistryDNSSuffix is not empty' { + It "should match the expected config file content" { + $expectedCredentialProviderConfig = @" +apiVersion: kubelet.config.k8s.io/v1 +kind: CredentialProviderConfig +providers: + - name: acr-credential-provider + matchImages: + - "*.azurecr.io" + - "*.azurecr.cn" + - "*.azurecr.de" + - "*.azurecr.us" + - "*.azurecr.microsoft.fakecloud" + defaultCacheDuration: "10m" + apiVersion: credentialprovider.kubelet.k8s.io/v1 + args: + - $global:KubeDir\azure.json + + +"@ + Config-CredentialProvider -CustomCloudContainerRegistryDNSSuffix ".azurecr.microsoft.fakecloud" + $acutalCredentialProviderConfigStr = Get-Content $CredentialProviderConfPATH -Raw | Out-String + $acutalCredentialProviderConfig = @" +$acutalCredentialProviderConfigStr +"@ + $diffence = Compare-Object $acutalCredentialProviderConfig $expectedCredentialProviderConfig + $diffence | Should -Be $null + } + } } \ No newline at end of file From becc45221cffe425e25cecf4c25020aea2d69f76 Mon Sep 17 00:00:00 2001 From: Qingchuan Hao Date: Fri, 12 Apr 2024 08:04:05 +0000 Subject: [PATCH 02/13] update comment and add try/catch block --- staging/cse/windows/configfunc.ps1 | 53 ++++++++++++++++-------------- 1 file changed, 29 insertions(+), 24 deletions(-) diff --git a/staging/cse/windows/configfunc.ps1 b/staging/cse/windows/configfunc.ps1 index 131f1056224..ec9c9ac7f69 100644 --- a/staging/cse/windows/configfunc.ps1 +++ b/staging/cse/windows/configfunc.ps1 @@ -386,30 +386,35 @@ function Install-CredentialProvider { [Parameter(Mandatory = $false)][string] $CustomCloudContainerRegistryDNSSuffix ) - Logs-To-Event -TaskName "AKS.WindowsCSE.Install-CredentialProvider" -TaskMessage "Start to install credential provider" - - $KubeletConfigArgsStr=$global:KubeletConfigArgs -join " " - # Starting from Kubernetes 1.30, out of tree credential provider is enabled as a must. Otherwise, related kubelet flags will be set. - if ($KubeletConfigArgsStr -Like "*image-credential-provider-config*" -And $KubeletConfigArgsStr -Like "*image-credential-provider-bin-dir*") { - Write-Log "Credential provider is enabled" - - Write-Log "Create credential provider configuration file" - Config-CredentialProvider -CustomCloudContainerRegistryDNSSuffix $CustomCloudContainerRegistryDNSSuffix - - $CredentialProviderBinDir = "c:\var\lib\kubelet\credential-provider" - Write-Log "Download credential provider binary from $global:CredentialProviderURL to $CredentialProviderBinDir" - $tempDir = New-TemporaryDirectory - $credentialproviderbinaryPackage = "$tempDir\credentialprovider.tar.gz" - DownloadFileOverHttp -Url $global:CredentialProviderURL -DestinationPath $credentialproviderbinaryPackage -ExitCode $global:WINDOWS_CSE_ERROR_DOWNLOAD_CREDEDNTIAL_PROVIDER - tar -xzf $credentialproviderbinaryPackage -C $tempDir - Create-Directory -FullPath $CredentialProviderBinDir - cp "$tempDir\azure-acr-credential-provider.exe" "$CredentialProviderBinDir\acr-credential-provider.exe" - # acr-credential-provider.exe cannot be found by kubelet through provider name before the fix https://github.com/kubernetes/kubernetes/pull/120291 - # so we copy the exe file to acr-credential-provider to make all 1.29 release work. - cp "$CredentialProviderBinDir\acr-credential-provider.exe" "$CredentialProviderBinDir\acr-credential-provider" - del $tempDir -Recurse - } else { - Write-Log "Credential provider is not enabled" + + try { + $KubeletConfigArgsStr=$global:KubeletConfigArgs -join " " + # Out of tree credential provider is turned on as a must after 1.30, and is optinal in 1.29, for cluster < 1.29, it's not enabled. + # And only when it's enabled, the credential provider flags are set. + if ($KubeletConfigArgsStr -Like "*image-credential-provider-config*" -And $KubeletConfigArgsStr -Like "*image-credential-provider-bin-dir*") { + Write-Log "Credential provider is enabled" + Logs-To-Event -TaskName "AKS.WindowsCSE.Install-CredentialProvider" -TaskMessage "Start to install credential provider" + + Write-Log "Create credential provider configuration file" + Config-CredentialProvider -CustomCloudContainerRegistryDNSSuffix $CustomCloudContainerRegistryDNSSuffix + + $CredentialProviderBinDir = "c:\var\lib\kubelet\credential-provider" + Write-Log "Download credential provider binary from $global:CredentialProviderURL to $CredentialProviderBinDir" + $tempDir = New-TemporaryDirectory + $credentialproviderbinaryPackage = "$tempDir\credentialprovider.tar.gz" + DownloadFileOverHttp -Url $global:CredentialProviderURL -DestinationPath $credentialproviderbinaryPackage -ExitCode $global:WINDOWS_CSE_ERROR_DOWNLOAD_CREDEDNTIAL_PROVIDER + tar -xzf $credentialproviderbinaryPackage -C $tempDir + Create-Directory -FullPath $CredentialProviderBinDir + cp "$tempDir\azure-acr-credential-provider.exe" "$CredentialProviderBinDir\acr-credential-provider.exe" + # acr-credential-provider.exe cannot be found by kubelet through provider name before the fix https://github.com/kubernetes/kubernetes/pull/120291 + # so we copy the exe file to acr-credential-provider to make all 1.29 release work. + cp "$CredentialProviderBinDir\acr-credential-provider.exe" "$CredentialProviderBinDir\acr-credential-provider" + del $tempDir -Recurse + } else { + Write-Log "Credential provider is not enabled" + } + } catch { + Set-ExitCode -ExitCode $global:WINDOWS_CSE_ERROR_INSTALL_CREDENTIAL_PROVIDER -ErrorMessage "Error installing credential provider. Error: $_" } } From 058b4d5a83be8679c6b08ac9ee5f71e9115d55f8 Mon Sep 17 00:00:00 2001 From: Qingchuan Hao Date: Fri, 12 Apr 2024 08:09:42 +0000 Subject: [PATCH 03/13] remove duplicated log --- staging/cse/windows/configfunc.ps1 | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/staging/cse/windows/configfunc.ps1 b/staging/cse/windows/configfunc.ps1 index ec9c9ac7f69..ec9288cd706 100644 --- a/staging/cse/windows/configfunc.ps1 +++ b/staging/cse/windows/configfunc.ps1 @@ -392,8 +392,7 @@ function Install-CredentialProvider { # Out of tree credential provider is turned on as a must after 1.30, and is optinal in 1.29, for cluster < 1.29, it's not enabled. # And only when it's enabled, the credential provider flags are set. if ($KubeletConfigArgsStr -Like "*image-credential-provider-config*" -And $KubeletConfigArgsStr -Like "*image-credential-provider-bin-dir*") { - Write-Log "Credential provider is enabled" - Logs-To-Event -TaskName "AKS.WindowsCSE.Install-CredentialProvider" -TaskMessage "Start to install credential provider" + Logs-To-Event -TaskName "AKS.WindowsCSE.Install-CredentialProvider" -TaskMessage "Start to install out of tree credential provider" Write-Log "Create credential provider configuration file" Config-CredentialProvider -CustomCloudContainerRegistryDNSSuffix $CustomCloudContainerRegistryDNSSuffix @@ -410,8 +409,6 @@ function Install-CredentialProvider { # so we copy the exe file to acr-credential-provider to make all 1.29 release work. cp "$CredentialProviderBinDir\acr-credential-provider.exe" "$CredentialProviderBinDir\acr-credential-provider" del $tempDir -Recurse - } else { - Write-Log "Credential provider is not enabled" } } catch { Set-ExitCode -ExitCode $global:WINDOWS_CSE_ERROR_INSTALL_CREDENTIAL_PROVIDER -ErrorMessage "Error installing credential provider. Error: $_" From f462c82aef5cc4032998353f2c2bd1e8943915ca Mon Sep 17 00:00:00 2001 From: Qingchuan Hao Date: Sat, 13 Apr 2024 15:55:24 +0800 Subject: [PATCH 04/13] use files to store expected test config content --- staging/cse/windows/configfunc.ps1 | 33 +++++++--- staging/cse/windows/configfunc.tests.ps1 | 62 +++++-------------- ...ontainerRegistryDNSSuffixEmpty.config.yaml | 13 ++++ ...ainerRegistryDNSSuffixNotEmpty.config.yaml | 14 +++++ 4 files changed, 64 insertions(+), 58 deletions(-) create mode 100644 staging/cse/windows/credentialProvider.tests.suites/CustomCloudContainerRegistryDNSSuffixEmpty.config.yaml create mode 100644 staging/cse/windows/credentialProvider.tests.suites/CustomCloudContainerRegistryDNSSuffixNotEmpty.config.yaml diff --git a/staging/cse/windows/configfunc.ps1 b/staging/cse/windows/configfunc.ps1 index ec9288cd706..1b3053013c5 100644 --- a/staging/cse/windows/configfunc.ps1 +++ b/staging/cse/windows/configfunc.ps1 @@ -344,14 +344,16 @@ function Install-OpenSSH { function Config-CredentialProvider { Param( + [Parameter(Mandatory=$true)][string] + $KubeDir, [Parameter(Mandatory = $false)][string] $CustomCloudContainerRegistryDNSSuffix ) - $CredentialProviderConfPATH = [Io.path]::Combine("$global:KubeDir", "credential-provider-config.yaml") + $CredentialProviderConfPATH = [Io.path]::Combine("$KubeDir", "credential-provider-config.yaml") Write-Log "Configuring kubelet credential provider" - $azureConfigFile = [io.path]::Combine($global:KubeDir, "azure.json") + $azureConfigFile = [io.path]::Combine("$KubeDir", "azure.json") $credentialProviderConfig = @" apiVersion: kubelet.config.k8s.io/v1 @@ -363,26 +365,37 @@ providers: - "*.azurecr.cn" - "*.azurecr.de" - "*.azurecr.us" + defaultCacheDuration: "10m" + apiVersion: credentialprovider.kubelet.k8s.io/v1 + args: + - $azureConfigFile "@ - if ($CustomCloudContainerRegistryDNSSuffix) { - $credentialProviderConfig += @" + if ($CustomCloudContainerRegistryDNSSuffix) { + $credentialProviderConfig = @" +apiVersion: kubelet.config.k8s.io/v1 +kind: CredentialProviderConfig +providers: + - name: acr-credential-provider + matchImages: + - "*.azurecr.io" + - "*.azurecr.cn" + - "*.azurecr.de" + - "*.azurecr.us" - "*$CustomCloudContainerRegistryDNSSuffix" -"@ - } - - $credentialProviderConfig+=@" - defaultCacheDuration: "10m" apiVersion: credentialprovider.kubelet.k8s.io/v1 args: - $azureConfigFile "@ + } $credentialProviderConfig | Out-File -encoding ASCII -filepath "$CredentialProviderConfPATH" } function Install-CredentialProvider { Param( + [Parameter(Mandatory=$true)][string] + $KubeDir, [Parameter(Mandatory = $false)][string] $CustomCloudContainerRegistryDNSSuffix ) @@ -395,7 +408,7 @@ function Install-CredentialProvider { Logs-To-Event -TaskName "AKS.WindowsCSE.Install-CredentialProvider" -TaskMessage "Start to install out of tree credential provider" Write-Log "Create credential provider configuration file" - Config-CredentialProvider -CustomCloudContainerRegistryDNSSuffix $CustomCloudContainerRegistryDNSSuffix + Config-CredentialProvider -KubeDir $KubeDir -CustomCloudContainerRegistryDNSSuffix $CustomCloudContainerRegistryDNSSuffix $CredentialProviderBinDir = "c:\var\lib\kubelet\credential-provider" Write-Log "Download credential provider binary from $global:CredentialProviderURL to $CredentialProviderBinDir" diff --git a/staging/cse/windows/configfunc.tests.ps1 b/staging/cse/windows/configfunc.tests.ps1 index 1904fa2b6b8..8ad485489d7 100644 --- a/staging/cse/windows/configfunc.tests.ps1 +++ b/staging/cse/windows/configfunc.tests.ps1 @@ -108,8 +108,13 @@ Describe 'Resize-OSDrive' { Describe 'Config-CredentialProvider' { BeforeEach { - $global:KubeDir = "$PSScriptRoot" - $CredentialProviderConfPATH=[Io.path]::Combine("$global:KubeDir", "credential-provider-config.yaml") + $global:credentialProviderConfigDir = "staging\cse\windows\credentialProvider.tests.suites" + $CredentialProviderConfPATH=[Io.path]::Combine("$global:credentialProviderConfigDir", "credential-provider-config.yaml") + function Read-Format-Yaml ([string]$YamlFile) { + $yaml = Get-Content $YamlFile | ConvertFrom-Yaml + $yaml = $yaml | ConvertTo-Yaml + return $yaml + } } AfterEach { @@ -118,59 +123,20 @@ Describe 'Config-CredentialProvider' { Context 'CustomCloudContainerRegistryDNSSuffix is empty' { It "should match the expected config file content" { - $expectedCredentialProviderConfig = @" -apiVersion: kubelet.config.k8s.io/v1 -kind: CredentialProviderConfig -providers: - - name: acr-credential-provider - matchImages: - - "*.azurecr.io" - - "*.azurecr.cn" - - "*.azurecr.de" - - "*.azurecr.us" - defaultCacheDuration: "10m" - apiVersion: credentialprovider.kubelet.k8s.io/v1 - args: - - $global:KubeDir\azure.json - - -"@ - Config-CredentialProvider -CustomCloudContainerRegistryDNSSuffix "" - $acutalCredentialProviderConfigStr = Get-Content $CredentialProviderConfPATH -Raw | Out-String - $acutalCredentialProviderConfig = @" -$acutalCredentialProviderConfigStr -"@ + $expectedCredentialProviderConfig = Read-Format-Yaml ([Io.path]::Combine($credentialProviderConfigDir, "CustomCloudContainerRegistryDNSSuffixEmpty.config.yaml")) + Config-CredentialProvider -KubeDir $credentialProviderConfigDir -CustomCloudContainerRegistryDNSSuffix "" + $acutalCredentialProviderConfig = Read-Format-Yaml $CredentialProviderConfPATH $diffence = Compare-Object $acutalCredentialProviderConfig $expectedCredentialProviderConfig $diffence | Should -Be $null } } Context 'CustomCloudContainerRegistryDNSSuffix is not empty' { It "should match the expected config file content" { - $expectedCredentialProviderConfig = @" -apiVersion: kubelet.config.k8s.io/v1 -kind: CredentialProviderConfig -providers: - - name: acr-credential-provider - matchImages: - - "*.azurecr.io" - - "*.azurecr.cn" - - "*.azurecr.de" - - "*.azurecr.us" - - "*.azurecr.microsoft.fakecloud" - defaultCacheDuration: "10m" - apiVersion: credentialprovider.kubelet.k8s.io/v1 - args: - - $global:KubeDir\azure.json - - -"@ - Config-CredentialProvider -CustomCloudContainerRegistryDNSSuffix ".azurecr.microsoft.fakecloud" - $acutalCredentialProviderConfigStr = Get-Content $CredentialProviderConfPATH -Raw | Out-String - $acutalCredentialProviderConfig = @" -$acutalCredentialProviderConfigStr -"@ + $expectedCredentialProviderConfig = Read-Format-Yaml ([Io.path]::Combine($credentialProviderConfigDir, "CustomCloudContainerRegistryDNSSuffixNotEmpty.config.yaml")) + Config-CredentialProvider -KubeDir $credentialProviderConfigDir -CustomCloudContainerRegistryDNSSuffix ".azurecr.microsoft.fakecloud" + $acutalCredentialProviderConfig = Read-Format-Yaml $CredentialProviderConfPATH $diffence = Compare-Object $acutalCredentialProviderConfig $expectedCredentialProviderConfig $diffence | Should -Be $null - } + } } } \ No newline at end of file diff --git a/staging/cse/windows/credentialProvider.tests.suites/CustomCloudContainerRegistryDNSSuffixEmpty.config.yaml b/staging/cse/windows/credentialProvider.tests.suites/CustomCloudContainerRegistryDNSSuffixEmpty.config.yaml new file mode 100644 index 00000000000..6b44f1f689f --- /dev/null +++ b/staging/cse/windows/credentialProvider.tests.suites/CustomCloudContainerRegistryDNSSuffixEmpty.config.yaml @@ -0,0 +1,13 @@ +apiVersion: kubelet.config.k8s.io/v1 +kind: CredentialProviderConfig +providers: + - name: acr-credential-provider + matchImages: + - "*.azurecr.io" + - "*.azurecr.cn" + - "*.azurecr.de" + - "*.azurecr.us" + defaultCacheDuration: "10m" + apiVersion: credentialprovider.kubelet.k8s.io/v1 + args: + - staging\cse\windows\credentialProvider.tests.suites\azure.json diff --git a/staging/cse/windows/credentialProvider.tests.suites/CustomCloudContainerRegistryDNSSuffixNotEmpty.config.yaml b/staging/cse/windows/credentialProvider.tests.suites/CustomCloudContainerRegistryDNSSuffixNotEmpty.config.yaml new file mode 100644 index 00000000000..bbacd06da00 --- /dev/null +++ b/staging/cse/windows/credentialProvider.tests.suites/CustomCloudContainerRegistryDNSSuffixNotEmpty.config.yaml @@ -0,0 +1,14 @@ +apiVersion: kubelet.config.k8s.io/v1 +kind: CredentialProviderConfig +providers: + - name: acr-credential-provider + matchImages: + - "*.azurecr.io" + - "*.azurecr.cn" + - "*.azurecr.de" + - "*.azurecr.us" + - "*.azurecr.microsoft.fakecloud" + defaultCacheDuration: "10m" + apiVersion: credentialprovider.kubelet.k8s.io/v1 + args: + - staging\cse\windows\credentialProvider.tests.suites\azure.json From 685c02f7816567e2590eeae98908eec2a0da9af0 Mon Sep 17 00:00:00 2001 From: Qingchuan Hao Date: Sat, 13 Apr 2024 15:55:42 +0800 Subject: [PATCH 05/13] install yaml module to read yaml config file for windows cse test --- .github/workflows/validate-windows-ut.yml | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/.github/workflows/validate-windows-ut.yml b/.github/workflows/validate-windows-ut.yml index 57008a23f21..156505079aa 100644 --- a/.github/workflows/validate-windows-ut.yml +++ b/.github/workflows/validate-windows-ut.yml @@ -15,4 +15,5 @@ jobs: - name: Perform a Pester test from the staging/cse/windows/*.tests.ps1 file shell: powershell run: | - Invoke-Pester staging/cse/windows/*.tests.ps1 -Passthru \ No newline at end of file + Install-Module -Name powershell-yaml -Force + Invoke-Pester staging/cse/windows/*.tests.ps1 -Passthru From 2b72c73c5bd5437a8f6ab6093774b359d4e0e790 Mon Sep 17 00:00:00 2001 From: Qingchuan Hao Date: Sat, 13 Apr 2024 16:16:28 +0800 Subject: [PATCH 06/13] collect credential provider config in debug script --- staging/cse/windows/debug/collect-windows-logs.ps1 | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/staging/cse/windows/debug/collect-windows-logs.ps1 b/staging/cse/windows/debug/collect-windows-logs.ps1 index 1b1a2d04e1c..769a39efc7f 100644 --- a/staging/cse/windows/debug/collect-windows-logs.ps1 +++ b/staging/cse/windows/debug/collect-windows-logs.ps1 @@ -77,6 +77,12 @@ if (Test-Path "c:\k\bootstrap-config") { $paths += "c:\k\bootstrap-config" } + +if (Test-Path "c:\k\credential-provider-config.yaml") { + Write-Host "Collecting credential provider config" + $paths += "c:\k\credential-provider-config.yaml" +} + Write-Host "Collecting Azure CNI configurations" $paths += "C:\k\azurecni\netconf\10-azure.conflist" $azureCNIConfigurations = @( From 37731ce88d3ee718f0ac998eba1d1cde3b9f1258 Mon Sep 17 00:00:00 2001 From: Qingchuan Hao Date: Mon, 15 Apr 2024 15:33:27 +0800 Subject: [PATCH 07/13] address comments --- staging/cse/windows/configfunc.ps1 | 2 +- staging/cse/windows/provisioningscripts/loggenerator.ps1 | 3 ++- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/staging/cse/windows/configfunc.ps1 b/staging/cse/windows/configfunc.ps1 index 1b3053013c5..54f74ff7010 100644 --- a/staging/cse/windows/configfunc.ps1 +++ b/staging/cse/windows/configfunc.ps1 @@ -371,7 +371,7 @@ providers: - $azureConfigFile "@ - if ($CustomCloudContainerRegistryDNSSuffix) { + if (![string]::IsNullOrEmpty($CustomCloudContainerRegistryDNSSuffix)) { $credentialProviderConfig = @" apiVersion: kubelet.config.k8s.io/v1 kind: CredentialProviderConfig diff --git a/staging/cse/windows/provisioningscripts/loggenerator.ps1 b/staging/cse/windows/provisioningscripts/loggenerator.ps1 index fbea60e5f54..58204c682e6 100644 --- a/staging/cse/windows/provisioningscripts/loggenerator.ps1 +++ b/staging/cse/windows/provisioningscripts/loggenerator.ps1 @@ -81,7 +81,8 @@ $kLogFiles = @( "containerd.log", "containerd.err.log", "hnsremediator.log", - "windowslogscleanup.log" + "windowslogscleanup.log", + "credential-provider-config.yaml" ) $kLogFiles | Foreach-Object { Create-SymbolLinkFile -SrcFile (Join-Path "C:\k\" $_) -DestFile (Join-Path $aksLogFolder $_) From e5106b5fd6f6a5b1c8e74379b21981ad27ff3aa6 Mon Sep 17 00:00:00 2001 From: Qingchuan Hao Date: Mon, 15 Apr 2024 18:20:13 +0800 Subject: [PATCH 08/13] check credential provider flags --- staging/cse/windows/configfunc.ps1 | 69 ++++++++++++++++-------- staging/cse/windows/configfunc.tests.ps1 | 5 +- 2 files changed, 51 insertions(+), 23 deletions(-) diff --git a/staging/cse/windows/configfunc.ps1 b/staging/cse/windows/configfunc.ps1 index 54f74ff7010..5d4ef73b8c2 100644 --- a/staging/cse/windows/configfunc.ps1 +++ b/staging/cse/windows/configfunc.ps1 @@ -346,12 +346,12 @@ function Config-CredentialProvider { Param( [Parameter(Mandatory=$true)][string] $KubeDir, + [Parameter(Mandatory=$true)][string] + $CredentialProviderConfPath, [Parameter(Mandatory = $false)][string] $CustomCloudContainerRegistryDNSSuffix ) - $CredentialProviderConfPATH = [Io.path]::Combine("$KubeDir", "credential-provider-config.yaml") - Write-Log "Configuring kubelet credential provider" $azureConfigFile = [io.path]::Combine("$KubeDir", "azure.json") @@ -401,28 +401,55 @@ function Install-CredentialProvider { ) try { - $KubeletConfigArgsStr=$global:KubeletConfigArgs -join " " # Out of tree credential provider is turned on as a must after 1.30, and is optinal in 1.29, for cluster < 1.29, it's not enabled. # And only when it's enabled, the credential provider flags are set. - if ($KubeletConfigArgsStr -Like "*image-credential-provider-config*" -And $KubeletConfigArgsStr -Like "*image-credential-provider-bin-dir*") { - Logs-To-Event -TaskName "AKS.WindowsCSE.Install-CredentialProvider" -TaskMessage "Start to install out of tree credential provider" - - Write-Log "Create credential provider configuration file" - Config-CredentialProvider -KubeDir $KubeDir -CustomCloudContainerRegistryDNSSuffix $CustomCloudContainerRegistryDNSSuffix - - $CredentialProviderBinDir = "c:\var\lib\kubelet\credential-provider" - Write-Log "Download credential provider binary from $global:CredentialProviderURL to $CredentialProviderBinDir" - $tempDir = New-TemporaryDirectory - $credentialproviderbinaryPackage = "$tempDir\credentialprovider.tar.gz" - DownloadFileOverHttp -Url $global:CredentialProviderURL -DestinationPath $credentialproviderbinaryPackage -ExitCode $global:WINDOWS_CSE_ERROR_DOWNLOAD_CREDEDNTIAL_PROVIDER - tar -xzf $credentialproviderbinaryPackage -C $tempDir - Create-Directory -FullPath $CredentialProviderBinDir - cp "$tempDir\azure-acr-credential-provider.exe" "$CredentialProviderBinDir\acr-credential-provider.exe" - # acr-credential-provider.exe cannot be found by kubelet through provider name before the fix https://github.com/kubernetes/kubernetes/pull/120291 - # so we copy the exe file to acr-credential-provider to make all 1.29 release work. - cp "$CredentialProviderBinDir\acr-credential-provider.exe" "$CredentialProviderBinDir\acr-credential-provider" - del $tempDir -Recurse + function getKubeletFlagValue { + Param( + [Parameter(Mandatory=$true)][string] + $KubeletConfigArg + ) + $splitResult=($KubeletConfigArg -split "=") + if ($splitResult.Length -ne 2) { + Set-ExitCode -ExitCode $global:WINDOWS_CSE_ERROR_CREDENTIAL_PROVIDER_CONFIG -ErrorMessage "Failed to get kubelet flag value from flag $KubeletConfigArg" + } + return $splitResult[1] + } + $credentialProviderConfigPath = "" + $credentialProviderBinDir = "" + ForEach ($kubeletConfigArg in $global:KubeletConfigArgs){ + if ($kubeletConfigArg -like "--image-credential-provider-config*") { + $credentialProviderConfigPath=getKubeletFlagValue -KubeletConfigArg $kubeletConfigArg + } + if ($kubeletConfigArg -like "--image-credential-provider-bin-dir*") { + $credentialProviderBinDir=getKubeletFlagValue -KubeletConfigArg $kubeletConfigArg + } + } + + # Both flags should be set to enable out of tree credential provider or not set at the same time to disable it. + if ([string]::IsNullOrEmpty($credentialProviderConfigPath) -xor [string]::IsNullOrEmpty($credentialProviderBinDir)) { + Set-ExitCode -ExitCode $global:WINDOWS_CSE_ERROR_CREDENTIAL_PROVIDER_CONFIG -ErrorMessage "Not all credential provider flags are configured: --image-credential-provider-config=$imageCredentialProviderConfigPath, --image-credential-provider-bin-dir=$imageCredentialProviderBinDir" } + if ([string]::IsNullOrEmpty($credentialProviderConfigPath) -and [string]::IsNullOrEmpty($credentialProviderBinDir)) { + Write-Log "Out of tree credential provider is not enabled" + return + } + + Logs-To-Event -TaskName "AKS.WindowsCSE.Install-CredentialProvider" -TaskMessage "Start to install out of tree credential provider" + + Write-Log "Create credential provider configuration file" + Config-CredentialProvider -KubeDir $KubeDir -CredentialProviderConfPath $credentialProviderConfigPath -CustomCloudContainerRegistryDNSSuffix $CustomCloudContainerRegistryDNSSuffix + + Write-Log "Download credential provider binary from $global:CredentialProviderURL to $credentialProviderBinDir" + $tempDir = New-TemporaryDirectory + $credentialproviderbinaryPackage = "$tempDir\credentialprovider.tar.gz" + DownloadFileOverHttp -Url $global:CredentialProviderURL -DestinationPath $credentialproviderbinaryPackage -ExitCode $global:WINDOWS_CSE_ERROR_DOWNLOAD_CREDEDNTIAL_PROVIDER + tar -xzf $credentialproviderbinaryPackage -C $tempDir + Create-Directory -FullPath $credentialProviderBinDir + cp "$tempDir\azure-acr-credential-provider.exe" "$credentialProviderBinDir\acr-credential-provider.exe" + # acr-credential-provider.exe cannot be found by kubelet through provider name before the fix https://github.com/kubernetes/kubernetes/pull/120291 + # so we copy the exe file to acr-credential-provider to make all 1.29 release work. + cp "$credentialProviderBinDir\acr-credential-provider.exe" "$credentialProviderBinDir\acr-credential-provider" + del $tempDir -Recurse } catch { Set-ExitCode -ExitCode $global:WINDOWS_CSE_ERROR_INSTALL_CREDENTIAL_PROVIDER -ErrorMessage "Error installing credential provider. Error: $_" } diff --git a/staging/cse/windows/configfunc.tests.ps1 b/staging/cse/windows/configfunc.tests.ps1 index 8ad485489d7..3e4ac76a641 100644 --- a/staging/cse/windows/configfunc.tests.ps1 +++ b/staging/cse/windows/configfunc.tests.ps1 @@ -124,7 +124,8 @@ Describe 'Config-CredentialProvider' { Context 'CustomCloudContainerRegistryDNSSuffix is empty' { It "should match the expected config file content" { $expectedCredentialProviderConfig = Read-Format-Yaml ([Io.path]::Combine($credentialProviderConfigDir, "CustomCloudContainerRegistryDNSSuffixEmpty.config.yaml")) - Config-CredentialProvider -KubeDir $credentialProviderConfigDir -CustomCloudContainerRegistryDNSSuffix "" + Config-CredentialProvider -KubeDir $credentialProviderConfigDir -CredentialProviderConfPath $CredentialProviderConfPATH -CustomCloudContainerRegistryDNSSuffix "" + $acutalCredentialProviderConfig = Read-Format-Yaml $CredentialProviderConfPATH $diffence = Compare-Object $acutalCredentialProviderConfig $expectedCredentialProviderConfig $diffence | Should -Be $null @@ -133,7 +134,7 @@ Describe 'Config-CredentialProvider' { Context 'CustomCloudContainerRegistryDNSSuffix is not empty' { It "should match the expected config file content" { $expectedCredentialProviderConfig = Read-Format-Yaml ([Io.path]::Combine($credentialProviderConfigDir, "CustomCloudContainerRegistryDNSSuffixNotEmpty.config.yaml")) - Config-CredentialProvider -KubeDir $credentialProviderConfigDir -CustomCloudContainerRegistryDNSSuffix ".azurecr.microsoft.fakecloud" + Config-CredentialProvider -KubeDir $credentialProviderConfigDir -CredentialProviderConfPath $CredentialProviderConfPATH -CustomCloudContainerRegistryDNSSuffix ".azurecr.microsoft.fakecloud" $acutalCredentialProviderConfig = Read-Format-Yaml $CredentialProviderConfPATH $diffence = Compare-Object $acutalCredentialProviderConfig $expectedCredentialProviderConfig $diffence | Should -Be $null From a801766d209541708d88d815dd3dd30177d11b4a Mon Sep 17 00:00:00 2001 From: Qingchuan Hao Date: Tue, 16 Apr 2024 09:08:26 +0800 Subject: [PATCH 09/13] add more ut --- .../linux/cloud-init/artifacts/cse_helpers.sh | 1 + parts/windows/windowscsehelper.ps1 | 9 ++- staging/cse/windows/configfunc.ps1 | 60 +++++++++-------- staging/cse/windows/configfunc.tests.ps1 | 65 +++++++++++++++++++ 4 files changed, 108 insertions(+), 27 deletions(-) diff --git a/parts/linux/cloud-init/artifacts/cse_helpers.sh b/parts/linux/cloud-init/artifacts/cse_helpers.sh index 34f13e6da0c..4f829c70e5b 100755 --- a/parts/linux/cloud-init/artifacts/cse_helpers.sh +++ b/parts/linux/cloud-init/artifacts/cse_helpers.sh @@ -99,6 +99,7 @@ ERR_K8S_INSTALL_ERR=204 # Error installing or setting up kubernetes binaries on ERR_SYSTEMCTL_MASK_FAIL=2 # Service could not be masked by systemctl ERR_CREDENTIAL_PROVIDER_DOWNLOAD_TIMEOUT=205 # Timeout waiting for credential provider downloads +ERR_CREDENTIAL_PROVIDER_CONFIG=206 # Error checking credential provider flags OS=$(sort -r /etc/*-release | gawk 'match($0, /^(ID_LIKE=(coreos)|ID=(.*))$/, a) { print toupper(a[2] a[3]); exit }') OS_VERSION=$(sort -r /etc/*-release | gawk 'match($0, /^(VERSION_ID=(.*))$/, a) { print toupper(a[2] a[3]); exit }' | tr -d '"') diff --git a/parts/windows/windowscsehelper.ps1 b/parts/windows/windowscsehelper.ps1 index e6c77a57ecd..7d95ce47c7d 100644 --- a/parts/windows/windowscsehelper.ps1 +++ b/parts/windows/windowscsehelper.ps1 @@ -68,6 +68,10 @@ $global:WINDOWS_CSE_ERROR_GPU_DRIVER_INSTALLATION_URL_NOT_EXE=61 $global:WINDOWS_CSE_ERROR_UPDATING_KUBE_CLUSTER_CONFIG=62 $global:WINDOWS_CSE_ERROR_GET_NODE_IPV6_IP=63 $global:WINDOWS_CSE_ERROR_GET_CONTAINERD_VERSION=64 +$global:WINDOWS_CSE_ERROR_INSTALL_CREDENTIAL_PROVIDER = 65 # exit code for installing credential provider + +$global:WINDOWS_CSE_ERROR_DOWNLOAD_CREDEDNTIAL_PROVIDER=205 # exit code for downloading credential provider failure +$global:WINDOWS_CSE_ERROR_CREDENTIAL_PROVIDER_CONFIG=206 # exit code for checking credential provider config failure # Please add new error code for downloading new packages in RP code too $global:ErrorCodeNames = @( @@ -135,7 +139,10 @@ $global:ErrorCodeNames = @( "WINDOWS_CSE_ERROR_GPU_DRIVER_INSTALLATION_URL_NOT_EXE", "WINDOWS_CSE_ERROR_UPDATING_KUBE_CLUSTER_CONFIG", "WINDOWS_CSE_ERROR_GET_NODE_IPV6_IP", - "WINDOWS_CSE_ERROR_GET_CONTAINERD_VERSION" + "WINDOWS_CSE_ERROR_GET_CONTAINERD_VERSION", + "WINDOWS_CSE_ERROR_INSTALL_CREDENTIAL_PROVIDER", + "WINDOWS_CSE_ERROR_DOWNLOAD_CREDEDNTIAL_PROVIDER", + "WINDOWS_CSE_ERROR_CREDENTIAL_PROVIDER_CONFIG" ) # NOTE: KubernetesVersion does not contain "v" diff --git a/staging/cse/windows/configfunc.ps1 b/staging/cse/windows/configfunc.ps1 index 5d4ef73b8c2..4fda8eb5646 100644 --- a/staging/cse/windows/configfunc.ps1 +++ b/staging/cse/windows/configfunc.ps1 @@ -392,6 +392,38 @@ providers: $credentialProviderConfig | Out-File -encoding ASCII -filepath "$CredentialProviderConfPATH" } +function Validate-CredentialProviderConfigFlags { + function get-KubeletFlagValue { + Param( + [Parameter(Mandatory=$true)][string] + $KubeletConfigArg + ) + $splitResult=($KubeletConfigArg -split "=") + if ($splitResult.Length -ne 2 -or [string]::IsNullOrEmpty($splitResult[1])){ + Set-ExitCode -ExitCode $global:WINDOWS_CSE_ERROR_CREDENTIAL_PROVIDER_CONFIG -ErrorMessage "Failed to get kubelet flag value from flag $KubeletConfigArg" + } + return $splitResult[1] + } + $credentialProviderConfigPath = "" + $credentialProviderBinDir = "" + ForEach ($kubeletConfigArg in $global:KubeletConfigArgs){ + if ($kubeletConfigArg -like "--image-credential-provider-config*") { + $credentialProviderConfigPath=get-KubeletFlagValue -KubeletConfigArg $kubeletConfigArg + } + if ($kubeletConfigArg -like "--image-credential-provider-bin-dir*") { + $credentialProviderBinDir=get-KubeletFlagValue -KubeletConfigArg $kubeletConfigArg + } + } + echo $credentialProviderConfigPath + echo $credentialProviderBinDir + + # Both flags should be set to enable out of tree credential provider or not set at the same time to disable it. + if ([string]::IsNullOrEmpty($credentialProviderConfigPath) -xor [string]::IsNullOrEmpty($credentialProviderBinDir)) { + Set-ExitCode -ExitCode $global:WINDOWS_CSE_ERROR_CREDENTIAL_PROVIDER_CONFIG -ErrorMessage "Not all credential provider flags are configured: --image-credential-provider-config=$credentialProviderConfigPath, --image-credential-provider-bin-dir=$credentialProviderBinDir" + } + return $credentialProviderConfigPath, $credentialProviderBinDir +} + function Install-CredentialProvider { Param( [Parameter(Mandatory=$true)][string] @@ -403,32 +435,8 @@ function Install-CredentialProvider { try { # Out of tree credential provider is turned on as a must after 1.30, and is optinal in 1.29, for cluster < 1.29, it's not enabled. # And only when it's enabled, the credential provider flags are set. - function getKubeletFlagValue { - Param( - [Parameter(Mandatory=$true)][string] - $KubeletConfigArg - ) - $splitResult=($KubeletConfigArg -split "=") - if ($splitResult.Length -ne 2) { - Set-ExitCode -ExitCode $global:WINDOWS_CSE_ERROR_CREDENTIAL_PROVIDER_CONFIG -ErrorMessage "Failed to get kubelet flag value from flag $KubeletConfigArg" - } - return $splitResult[1] - } - $credentialProviderConfigPath = "" - $credentialProviderBinDir = "" - ForEach ($kubeletConfigArg in $global:KubeletConfigArgs){ - if ($kubeletConfigArg -like "--image-credential-provider-config*") { - $credentialProviderConfigPath=getKubeletFlagValue -KubeletConfigArg $kubeletConfigArg - } - if ($kubeletConfigArg -like "--image-credential-provider-bin-dir*") { - $credentialProviderBinDir=getKubeletFlagValue -KubeletConfigArg $kubeletConfigArg - } - } - - # Both flags should be set to enable out of tree credential provider or not set at the same time to disable it. - if ([string]::IsNullOrEmpty($credentialProviderConfigPath) -xor [string]::IsNullOrEmpty($credentialProviderBinDir)) { - Set-ExitCode -ExitCode $global:WINDOWS_CSE_ERROR_CREDENTIAL_PROVIDER_CONFIG -ErrorMessage "Not all credential provider flags are configured: --image-credential-provider-config=$imageCredentialProviderConfigPath, --image-credential-provider-bin-dir=$imageCredentialProviderBinDir" - } + $credentialProviderConfigs=Validate-CredentialProviderConfigFlags + $credentialProviderConfigPath, $credentialProviderBinDir = $credentialProviderConfigs[0], $credentialProviderConfigs[1] if ([string]::IsNullOrEmpty($credentialProviderConfigPath) -and [string]::IsNullOrEmpty($credentialProviderBinDir)) { Write-Log "Out of tree credential provider is not enabled" return diff --git a/staging/cse/windows/configfunc.tests.ps1 b/staging/cse/windows/configfunc.tests.ps1 index 3e4ac76a641..c8285fff935 100644 --- a/staging/cse/windows/configfunc.tests.ps1 +++ b/staging/cse/windows/configfunc.tests.ps1 @@ -140,4 +140,69 @@ Describe 'Config-CredentialProvider' { $diffence | Should -Be $null } } +} + +Describe 'Validate-CredentialProviderConfigFlags' { + BeforeEach { + $global:KubeletConfigArgs = @( "--address=0.0.0.0" ) + } + + BeforeAll{ + Mock Set-ExitCode -MockWith { + Param( + $ExitCode, + $ErrorMessage + ) + Write-Host "Set-ExitCode $ExitCode $ErrorMessage" + } -Verifiable + } + + Context 'success' { + It "Should return expected config path and bin path" { + $expectedCredentialProviderConfigPath="c:\k\credential-provider-config.yaml" + $expectedCredentialProviderBinDir="c:\var\lib\kubelet\credential-provider" + $global:KubeletConfigArgs+="--image-credential-provider-config="+$expectedCredentialProviderConfigPath + $global:KubeletConfigArgs+="--image-credential-provider-bin-dir="+$expectedCredentialProviderBinDir + $credentialProviderConfigs = Validate-CredentialProviderConfigFlags + $actualCredentialProviderConfigPath, $actualCredentialProviderBinDir = $credentialProviderConfigs[0], $credentialProviderConfigs[1] + Compare-Object $actualCredentialProviderConfigPath $expectedCredentialProviderConfigPath | Should -Be $null + Compare-Object $actualCredentialProviderBinDir $expectedCredentialProviderBinDir | Should -Be $null + } + + It "Should return empty config path and bin path" { + $expectedCredentialProviderConfigPath="" + $expectedCredentialProviderBinDir="" + $credentialProviderConfigs = Validate-CredentialProviderConfigFlags + $actualCredentialProviderConfigPath, $actualCredentialProviderBinDir = $credentialProviderConfigs[0], $credentialProviderConfigs[1] + Compare-Object $actualCredentialProviderConfigPath $expectedCredentialProviderConfigPath | Should -Be $null + Compare-Object $actualCredentialProviderBinDir $expectedCredentialProviderBinDir | Should -Be $null + } + } + + Context 'fail' { + It "Should call Set-ExitCode when only config path is specified" { + $expectedCredentialProviderConfigPath="c:\k\credential-provider_config.yaml" + $global:KubeletConfigArgs+="--image-credential-provider-config="+$expectedCredentialProviderConfigPath + $credentialProviderConfigs = Validate-CredentialProviderConfigFlags + Assert-MockCalled -CommandName "Set-ExitCode" -Exactly -Times 1 -ParameterFilter { $ExitCode -eq $global:WINDOWS_CSE_ERROR_CREDENTIAL_PROVIDER_CONFIG } + } + It "Should call Set-ExitCode when only bin dir is specified" { + $expectedCredentialProviderBinDir="c:\var\lib\kubelet\credential-provider" + $global:KubeletConfigArgs+="--image-credential-provider-bin-dir="+$expectedCredentialProviderBinDir + $credentialProviderConfigs = Validate-CredentialProviderConfigFlags + Assert-MockCalled -CommandName "Set-ExitCode" -Exactly -Times 1 -ParameterFilter { $ExitCode -eq $global:WINDOWS_CSE_ERROR_CREDENTIAL_PROVIDER_CONFIG } + } + It "Should call Set-ExitCode when flag value is emtpy string" { + $expectedCredentialProviderBinDir="c:\var\lib\kubelet\credential-provider" + $global:KubeletConfigArgs+="--image-credential-provider-bin-dir=" + $credentialProviderConfigs = Validate-CredentialProviderConfigFlags + Assert-MockCalled -CommandName "Set-ExitCode" -Exactly -Times 1 -ParameterFilter { $ExitCode -eq $global:WINDOWS_CSE_ERROR_CREDENTIAL_PROVIDER_CONFIG } + } + It "Should call Set-ExitCode when flag value is emtpy" { + $expectedCredentialProviderBinDir="c:\var\lib\kubelet\credential-provider" + $global:KubeletConfigArgs+="--image-credential-provider-bin-dir" + $credentialProviderConfigs = Validate-CredentialProviderConfigFlags + Assert-MockCalled -CommandName "Set-ExitCode" -Exactly -Times 1 -ParameterFilter { $ExitCode -eq $global:WINDOWS_CSE_ERROR_CREDENTIAL_PROVIDER_CONFIG } + } + } } \ No newline at end of file From 59c6a25b6c20a616e7cfb5f6299ea1a4e28f459a Mon Sep 17 00:00:00 2001 From: Qingchuan Hao Date: Tue, 16 Apr 2024 02:46:41 +0000 Subject: [PATCH 10/13] fix windows cse exit code error --- parts/linux/cloud-init/artifacts/cse_helpers.sh | 1 - parts/windows/windowscsehelper.ps1 | 5 ++--- pkg/agent/testdata/AKSWindows2019+CustomCloud/CustomData | 2 +- pkg/agent/testdata/AKSWindows2019+CustomVnet/CustomData | 2 +- .../CustomData | 2 +- pkg/agent/testdata/AKSWindows2019+K8S116/CustomData | 2 +- pkg/agent/testdata/AKSWindows2019+K8S117/CustomData | 2 +- pkg/agent/testdata/AKSWindows2019+K8S118/CustomData | 2 +- pkg/agent/testdata/AKSWindows2019+K8S119+CSI/CustomData | 2 +- pkg/agent/testdata/AKSWindows2019+K8S119+FIPS/CustomData | 2 +- pkg/agent/testdata/AKSWindows2019+K8S119/CustomData | 2 +- .../CustomData | 2 +- .../testdata/AKSWindows2019+ManagedIdentity/CustomData | 2 +- .../testdata/AKSWindows2019+SecurityProfile/CustomData | 2 +- pkg/templates/templates_generated.go | 8 +++++++- 15 files changed, 21 insertions(+), 17 deletions(-) diff --git a/parts/linux/cloud-init/artifacts/cse_helpers.sh b/parts/linux/cloud-init/artifacts/cse_helpers.sh index 4f829c70e5b..34f13e6da0c 100755 --- a/parts/linux/cloud-init/artifacts/cse_helpers.sh +++ b/parts/linux/cloud-init/artifacts/cse_helpers.sh @@ -99,7 +99,6 @@ ERR_K8S_INSTALL_ERR=204 # Error installing or setting up kubernetes binaries on ERR_SYSTEMCTL_MASK_FAIL=2 # Service could not be masked by systemctl ERR_CREDENTIAL_PROVIDER_DOWNLOAD_TIMEOUT=205 # Timeout waiting for credential provider downloads -ERR_CREDENTIAL_PROVIDER_CONFIG=206 # Error checking credential provider flags OS=$(sort -r /etc/*-release | gawk 'match($0, /^(ID_LIKE=(coreos)|ID=(.*))$/, a) { print toupper(a[2] a[3]); exit }') OS_VERSION=$(sort -r /etc/*-release | gawk 'match($0, /^(VERSION_ID=(.*))$/, a) { print toupper(a[2] a[3]); exit }' | tr -d '"') diff --git a/parts/windows/windowscsehelper.ps1 b/parts/windows/windowscsehelper.ps1 index 7d95ce47c7d..40b0e34fc41 100644 --- a/parts/windows/windowscsehelper.ps1 +++ b/parts/windows/windowscsehelper.ps1 @@ -69,9 +69,8 @@ $global:WINDOWS_CSE_ERROR_UPDATING_KUBE_CLUSTER_CONFIG=62 $global:WINDOWS_CSE_ERROR_GET_NODE_IPV6_IP=63 $global:WINDOWS_CSE_ERROR_GET_CONTAINERD_VERSION=64 $global:WINDOWS_CSE_ERROR_INSTALL_CREDENTIAL_PROVIDER = 65 # exit code for installing credential provider - -$global:WINDOWS_CSE_ERROR_DOWNLOAD_CREDEDNTIAL_PROVIDER=205 # exit code for downloading credential provider failure -$global:WINDOWS_CSE_ERROR_CREDENTIAL_PROVIDER_CONFIG=206 # exit code for checking credential provider config failure +$global:WINDOWS_CSE_ERROR_DOWNLOAD_CREDEDNTIAL_PROVIDER=66 # exit code for downloading credential provider failure +$global:WINDOWS_CSE_ERROR_CREDENTIAL_PROVIDER_CONFIG=67 # exit code for checking credential provider config failure # Please add new error code for downloading new packages in RP code too $global:ErrorCodeNames = @( diff --git a/pkg/agent/testdata/AKSWindows2019+CustomCloud/CustomData b/pkg/agent/testdata/AKSWindows2019+CustomCloud/CustomData index 98f6dc58dea..e4b419e0da6 100644 --- a/pkg/agent/testdata/AKSWindows2019+CustomCloud/CustomData +++ b/pkg/agent/testdata/AKSWindows2019+CustomCloud/CustomData @@ -193,7 +193,7 @@ $global:TLSBootstrapToken = "" $global:IsDisableWindowsOutboundNat = [System.Convert]::ToBoolean("false"); # Base64 representation of ZIP archive -$zippedFiles = "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" +$zippedFiles = "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" $global:KubeClusterConfigPath = "c:\k\kubeclusterconfig.json" $fipsEnabled = [System.Convert]::ToBoolean("false") diff --git a/pkg/agent/testdata/AKSWindows2019+CustomVnet/CustomData b/pkg/agent/testdata/AKSWindows2019+CustomVnet/CustomData index a5b83f9f930..82d1c53c0a0 100644 --- a/pkg/agent/testdata/AKSWindows2019+CustomVnet/CustomData +++ b/pkg/agent/testdata/AKSWindows2019+CustomVnet/CustomData @@ -193,7 +193,7 @@ $global:TLSBootstrapToken = "" $global:IsDisableWindowsOutboundNat = [System.Convert]::ToBoolean("false"); # Base64 representation of ZIP archive -$zippedFiles = "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" +$zippedFiles = "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" $global:KubeClusterConfigPath = "c:\k\kubeclusterconfig.json" $fipsEnabled = [System.Convert]::ToBoolean("false") diff --git a/pkg/agent/testdata/AKSWindows2019+EnablePrivateClusterHostsConfigAgent/CustomData b/pkg/agent/testdata/AKSWindows2019+EnablePrivateClusterHostsConfigAgent/CustomData index 36be6bbd11b..e4b0b5bd8a3 100644 --- a/pkg/agent/testdata/AKSWindows2019+EnablePrivateClusterHostsConfigAgent/CustomData +++ b/pkg/agent/testdata/AKSWindows2019+EnablePrivateClusterHostsConfigAgent/CustomData @@ -193,7 +193,7 @@ $global:TLSBootstrapToken = "" $global:IsDisableWindowsOutboundNat = [System.Convert]::ToBoolean("false"); # Base64 representation of ZIP archive -$zippedFiles = "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" +$zippedFiles = "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" $global:KubeClusterConfigPath = "c:\k\kubeclusterconfig.json" $fipsEnabled = [System.Convert]::ToBoolean("false") diff --git a/pkg/agent/testdata/AKSWindows2019+K8S116/CustomData b/pkg/agent/testdata/AKSWindows2019+K8S116/CustomData index 5425658f4ad..b5cb19cbd7b 100644 --- a/pkg/agent/testdata/AKSWindows2019+K8S116/CustomData +++ b/pkg/agent/testdata/AKSWindows2019+K8S116/CustomData @@ -193,7 +193,7 @@ $global:TLSBootstrapToken = "" $global:IsDisableWindowsOutboundNat = [System.Convert]::ToBoolean("false"); # Base64 representation of ZIP archive -$zippedFiles = "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" +$zippedFiles = "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" $global:KubeClusterConfigPath = "c:\k\kubeclusterconfig.json" $fipsEnabled = [System.Convert]::ToBoolean("false") diff --git a/pkg/agent/testdata/AKSWindows2019+K8S117/CustomData b/pkg/agent/testdata/AKSWindows2019+K8S117/CustomData index d3692eb6756..b8aa28c4ff9 100644 --- a/pkg/agent/testdata/AKSWindows2019+K8S117/CustomData +++ b/pkg/agent/testdata/AKSWindows2019+K8S117/CustomData @@ -193,7 +193,7 @@ $global:TLSBootstrapToken = "" $global:IsDisableWindowsOutboundNat = [System.Convert]::ToBoolean("false"); # Base64 representation of ZIP archive -$zippedFiles = "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" +$zippedFiles = "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" $global:KubeClusterConfigPath = "c:\k\kubeclusterconfig.json" $fipsEnabled = [System.Convert]::ToBoolean("false") diff --git a/pkg/agent/testdata/AKSWindows2019+K8S118/CustomData b/pkg/agent/testdata/AKSWindows2019+K8S118/CustomData index 75830db31ab..eb369587256 100644 --- a/pkg/agent/testdata/AKSWindows2019+K8S118/CustomData +++ b/pkg/agent/testdata/AKSWindows2019+K8S118/CustomData @@ -193,7 +193,7 @@ $global:TLSBootstrapToken = "" $global:IsDisableWindowsOutboundNat = [System.Convert]::ToBoolean("false"); # Base64 representation of ZIP archive -$zippedFiles = "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" +$zippedFiles = "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" $global:KubeClusterConfigPath = "c:\k\kubeclusterconfig.json" $fipsEnabled = [System.Convert]::ToBoolean("false") diff --git a/pkg/agent/testdata/AKSWindows2019+K8S119+CSI/CustomData b/pkg/agent/testdata/AKSWindows2019+K8S119+CSI/CustomData index 4af4f4210cc..872f9ca49d3 100644 --- a/pkg/agent/testdata/AKSWindows2019+K8S119+CSI/CustomData +++ b/pkg/agent/testdata/AKSWindows2019+K8S119+CSI/CustomData @@ -193,7 +193,7 @@ $global:TLSBootstrapToken = "" $global:IsDisableWindowsOutboundNat = [System.Convert]::ToBoolean("false"); # Base64 representation of ZIP archive -$zippedFiles = "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" +$zippedFiles = "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" $global:KubeClusterConfigPath = "c:\k\kubeclusterconfig.json" $fipsEnabled = [System.Convert]::ToBoolean("false") diff --git a/pkg/agent/testdata/AKSWindows2019+K8S119+FIPS/CustomData b/pkg/agent/testdata/AKSWindows2019+K8S119+FIPS/CustomData index cb7a8edc2b7..440b3303d5f 100644 --- a/pkg/agent/testdata/AKSWindows2019+K8S119+FIPS/CustomData +++ b/pkg/agent/testdata/AKSWindows2019+K8S119+FIPS/CustomData @@ -193,7 +193,7 @@ $global:TLSBootstrapToken = "" $global:IsDisableWindowsOutboundNat = [System.Convert]::ToBoolean("false"); # Base64 representation of ZIP archive -$zippedFiles = "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" +$zippedFiles = "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" $global:KubeClusterConfigPath = "c:\k\kubeclusterconfig.json" $fipsEnabled = [System.Convert]::ToBoolean("true") diff --git a/pkg/agent/testdata/AKSWindows2019+K8S119/CustomData b/pkg/agent/testdata/AKSWindows2019+K8S119/CustomData index 904ca44f7d6..fb3736f275d 100644 --- a/pkg/agent/testdata/AKSWindows2019+K8S119/CustomData +++ b/pkg/agent/testdata/AKSWindows2019+K8S119/CustomData @@ -193,7 +193,7 @@ $global:TLSBootstrapToken = "" $global:IsDisableWindowsOutboundNat = [System.Convert]::ToBoolean("false"); # Base64 representation of ZIP archive -$zippedFiles = "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" +$zippedFiles = "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" $global:KubeClusterConfigPath = "c:\k\kubeclusterconfig.json" $fipsEnabled = [System.Convert]::ToBoolean("false") diff --git a/pkg/agent/testdata/AKSWindows2019+KubeletClientTLSBootstrapping/CustomData b/pkg/agent/testdata/AKSWindows2019+KubeletClientTLSBootstrapping/CustomData index 5e8793a850b..bf26b2af1ad 100644 --- a/pkg/agent/testdata/AKSWindows2019+KubeletClientTLSBootstrapping/CustomData +++ b/pkg/agent/testdata/AKSWindows2019+KubeletClientTLSBootstrapping/CustomData @@ -193,7 +193,7 @@ $global:TLSBootstrapToken = "07401b.f395accd246ae52d" $global:IsDisableWindowsOutboundNat = [System.Convert]::ToBoolean("false"); # Base64 representation of ZIP archive -$zippedFiles = "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" +$zippedFiles = "UEsDBBQACAAIAAAAAAAAAAAAAAAAAAAAAAAcAAAAd2luZG93cy93aW5kb3dzY3NlaGVscGVyLnBzMdR8XVPbyNL/PZ+iS/h/ArWRw0sgG2/pX6vIAnSwZZckQ3ISSiuksa0TWeNnZgRhs/nuT83o3ZaEydnn4nABRuq36e7p6d/MwD44y5AC9Um4ZhBSSCgKgGEI0DyMEdx7NPQhYWEE8yT2WYhjurcPhqC9R4whUqEuSCCMgS1RJpdCEgeIAGXeIowXb3yK3jyGcYAfaX9vbx+GKbcXRYC+hQx8HCAh4jYlAs3WU6WrhDJYecxfwh+fVflf7t0vf+z1FhG+96LBrWEOJ7e2q9m6a880Tbdt5ajxrW5ZE8udmdfm5NZUjmEfLjCBJEbf1shnKABECCbge8liyeD+SYzFF2rvI+x/5bZ9Te4RiRFDNBsKRSxZ99f0uEPlcHJrjibq0L0wRrp7azhXrqU71iflpIPJMG8m17qrf9S1maN+GOnKaQe1kGxOHFf/aNiO8raDVLvStWtXnRqurVs3uuVqE9PUNce4MZxPylkH51Sd2bprjNXLqq7zDo5L3XHt2QdTd9yppV8YH5V3ndSmbqmO7jqTa910LyaWq1pj5dcOFlN3bifWtWuYjm5dqJpuVyx7vwOjOlSnjm5VuI67smesmuqlPtZNxzWmVaau+GvqyNAmwt2Gpruqpk1mplPl7koEbWI6qmHq1lBwGKbtqKORPlSOuxJig8uamaZhXirHXZkxmeqmbV9tqulKiZzlwrD0W3U0ErzaxLwwLmcWZ+7KDsO8UUfG0J2qljrWeRQM01X/NbP0TIRy3JUu5sQdTrRr3XKdifthZoyGWYYWY1eOu3KHJ6emuppuOcaFoamObivHXTlTzONNrpOulNHHU+fTNktXwugmn/CurWvcF87IVk66MuRybKuu/nGqmkNXtbQr40ZXTrqSI2VIlUwnt7plX+mjkTu1jBtjpF/qyklXmghuW3dcS780bMf65E51a2zYtjExlZOubNnmvFFHM+6NziLCuYzxdGI5rqZd6je66djKSWclqbOo1zfT6Wh2aZg5c2dNmTjuxWRmDuuzXTnprCcFU5qJ5mz8QbeU067MKHmm1uTG4P4zzEvX1ixj6tjKaVeK2I5q8RIy1F1L5y5NuVxHta+V065sKbPY1t2pql2rl7py2pUuBcf17INumbqj2yVjV6aUqkyj5OjKkILjyrTd8WQ44+teV3JU5qQosoWWrvQomESeFCxdSVHxmsHD9fFTybdbzSgLcs74tis5eEwdbeoOP5nq2NBckcuWanK+rsRI0y8rjJv18G1XYkxnvAaUa7zytispUj2Oelln6ew8Shd8MEzV+pR3K10ZkftB/6iNZkO95oeuxOB8s2Gz/7pyI+dr0tddNVxtZjuTsTtUHZUPUHn7HvbBQiwhvC8Oad5g4gDxXtKnyF8FvHeExyWKQRt8Uf9MCBp6zPuiJZThFf/Yvw9jCDCiEGPGW2XKnjHDFjVhNnLc0eRSOTv6D6ywdQvRJGL9CC92N0KbTD9x3a42GY14azkxi6p21pW8lm4b/9Ldie0OLb6KnXUue9NZSmbl3YoqNF2oBu9bzjpXwBZexxjrk5mjnHUugC3MN2NXmM/ruj2b8szhdnSuiC2iZlbaStm6o5x1Lo7TmWtfz1zDvJiUC4py1rk6tigtcYpqjGaWrpx1tk9VKWkjZxuXpuoIzq6a2KZf/6jpU/5JOe+qjM/5TP+oK+ddWTabDlWHr7R8PXO10cx2UhjEW87zzpTTszXXmN6c857gvDPJdKda8250S7RI5125lY3I1Sx9qJuOoY7S5mCoW6DA+Rnsl2gZ5phAGFPmRVEYL8AnKEAxC70I1gQ/hAEiO61MXNWwrks5P9/SFODHOMJe0KIK5l4YJQR11YXtQRVuf7elz18i/2ubMh/H83BR6Nzbh2mEPIrACwKI0WO1ym0az1+vPf+rt0g3HKxpSscwLozXObuGA2R6K0RBgd8P9gAApOqosv0G6fX2qyzT0s2GdoK2rYF2jq19gXbS+qZAO13njkA7W+N2QDv51l5AF2nTRkA7fdcuwPNcW1sA7Swt8L/Dtc9A/w7OFti/M0cG+dvpG+H+8+QtUL8zY7thfkeInoX43fm2gbp3mIc7czTC+g7yTUjfYfg2nH+OuB3KP8PZAuNfwpVC+Gc4NuH7zuSb0L0rVxph+y4MVci+C30TXG/n64Lqu2RkCdN3oN6G6DswVeD5DtQlNN+BuA7Ld2CoQvIdyLfg+C48W1C8I3itMLydpwuCt3Ntwu/n5G9A753WhSrsfn7M2xC4m6cZbj/P8xI92zC7m7aGhbt81IpY25k20GpHTetEqi/ny1DqyxkbEerLxVTQaTfzNjJ9ubJNVLqjhA1EuiNXExp9OWsFibYzd6HQDpUbCLSbcht9ttN3IM9damoDiOyYbq1AUNo75GDOnDj6AK6L09YbRGiIK/tgPo6ZF8YgPUgFZhuHcbjyoi2u25AtRx5DlGkpFyIBKCAd909+7R9JsA+3YRSBv/TiBYKQAcPp2S8mBPkMHjLlYn/sEQFN1mtMmMCR+WG1X0rOyPf2YahPLZ03hsMBOEIgR7GCKMOfkJAIHrn2ewQUMQ5H1Ws7h6R9uEXpa4JW+AEJs+Y4ivAjB7IPHgm9+wgVJ+/zhCUE9QuP2Iy/Lkc9zbQqID0c98/7J8ey9yfnOH5zH8YeCRF9U45E3qCRszNv2VsF52/7zCP9xZ/S3r4YWyQc3OSH3JjNENSNedd//5wtFZIWU0r4/oBiRkd4sQjjxTAkXIk2+JJFS2xwfhnhBf0yjZJFGNMv49AnmOI562t4tU4Y6qc7sLa4y6B/Yyjmg/mSCv5SJp3j0a+mtxLDqD91whWymbdap6/2slsX8zBiiGQBpRAnaeoRz2eIUDj4cnQIj8vQX4JHEPjemoc04BGOKV310TcEOGHrhKX5GOHFAgXAlgQniyWs8SMidImiaC9TZAlFZhJFFL5DzwWZoHXk+QhefTl69RpevYIfezkxt5kKm7+D1Du4REweegyBfIHJymOADwfQcyXBkV37gFsSMiSP8OKgt0KUegt0CN/FzO+t6AIUyB/DX6V88T7lnKSj4cR7VbnDbMvmIozQ5AGRK8bWmeCpR7xVuiHDvz6L3xFD5GDsxYHHMHniehlJ0OHdZ8pIGC/uCvLejESvf5p5iCgLY4+bOPXYcmdBYcwqUvRvIdNwgMSTwz3xYx8uQsLn0BL5X3kRoghBOAeP5wyvA2yZ3q/h6RbzbyEFLyLIC57A9/wlCgCnheDmaphGgHNm6fnZmPS5xXeDwSViF9mLA+6NzIAeRR7xl2K361A8Cedw4CDKZM4IeXZrXNcwJHmc67xczzDklROTp1IZPdhkf12a91pw2ULEZM19ezcYqFGUywkRTQ36sVfYlWnsaziJGcgxgqOqQUVagjSjYhsx9VBezfG84h0ZNLx+4lTC1XOCV9DLNXw+ujvk4dgMvVTo4syywdAKMkcVjCBXmLYkiHnlo2xk/DuKKKp71U8ImhLMsI8jWgmNeB3GTQSf7SfK0KpvIta3+fuQPeUUztMa3Q0GKcUQzb0kYq9hFw4anWZ5wr/mmCDPX8JBb53R8RKVy9HjZJWG/saLEkSfN+mwGjvIQ7w9PjnGLFsWKBS6N5kbffeLUjLUqH/sbX+qG0weQh9NcRizsRd7C0S4QzaGwef6hsrSXT0cBVOCFwRROiVojgiKfT4re9tPS6ZGjld2GKGYRU98KQ3jBL2qqMn3uXmh5atePoxh6C1iTFno077N8PrRYz6vBDbzCDPRYyWpGHna8GbPIwuRWd9nJFR4wfgNxogtcaBIl4hJv8EkEXNc2UzwHzU5FmLkSdbwauXFARQfJCN+wF+RbCHKUrESyCpXmSqWOV+IKJylH5+GKPKebOTjOKBwfFRGL7uuV7feRkzOyy2Un3qVZ4RgMs4WKenCC6N0wa0eGvBR90FQiiWwIWXqzhduPqjMGJHQWQlU12sjpuFiyagWhSirXz3eDGymcg/xlgMUMNGjPLn/N+9IpbJdUdfrKPSFw3OJ/aHHPJ4cvKegfdGyOChCK+47qUF4P29geAzzZbeRcErwGhEWIvpZylcQ6Y6ncV5Km7jGPH4+/SwNEyIsHdOUqe4wPfLWFAXjMIpCmka3Lq3NeX2HeP5XMc6DVOVhJTzPTKfmmdm0jOSeQUG6SvCUaF8XftSamWoS7u3cxCjdzUN376G0tjDVfBdPU3dVhmojBsX84EMsfuETFn0LWTkXqtLSoRddeMak1NudfQ6iEsr7QY+mHQ1ae4QbzR948IjJV4/gJA6AhjxKEmACryDAAvvx15ywuLi7RkSIYSIOC1o3omKeclCzttoK/8Vb4f/3TnuV+kIcRZZmV0M5xZStcZzWK4+wDDAQyOLKcYXsYFnkI8gFQJDUa7ufIRDN1vu5nA0xUspSlCNRoXkMfIJ4K+7FwJWzcIWAeVQ0iiQVkbZ+4ywIXmpuWjhs3vskEQq4bDV9I+vfkJ8wBFKJGji+SKtvsuLmS2WZ/kPKLJWLEaftyx9SpnFNwtgP117UpHRavJRnFBEjAPuT7ehj4BmHY94EQLbQqr6f9nRWEo/QA4rgKlwsEWVZ+jASLhYi5iFNfYDzKdvL36UW/BPfO9kDWWUABaI57KtBkC0hB8dnh7xmIl6GQJ4UssQF97DNiyBnfsw9LZdDrLhCzg0oTOMtoYCVnCl3Kvi5U705/y5OunmjyhefalwttAgpQ2TTmDLPsmyQ/TKjjHidsGzxqAxrc9prIsWCnXKsOiVSPrno+n+iwm0VqYskip4HWEpv7kW0Gajl1sxots2wQDEiXgTrhKwxzYpVOt/FN75CyyZmNcyT23HYAi7SsUOQays5xMWDDTPKVZXnUwoZ+HeR/gUpbOiG/5/2BunCsgkSqkvUblakN7hoZaHahyVjazp484Yyz/+KHxCZR/ix7+PVG+/N6duzs/dnZ2/fnL9/d3xyXgaeD8JBqzUmHnkqlWfwf+2RtHXJu9AaAuV8/Les9cwDCL04w6sZ02USBneDgYke+aeMegfvHfwTh3HmyMwSIfqwlrr1nnTnvK0A+xsvCgOPIRMzM4miCdFXa/Z00JSSmZqd9wzaRS89uhSbexXpvGX+G0TXe42s9/4/kVtr5LPJKH7wlD3ohaDA0W/wG1Rn3jY62Ydh2hdEeAECNqRNg/i48p6KvWKKYhqy8AFB4DGvJqMyhYRh0AthAD0/jVe9FSbpXcp/FOGE37mqgqYEBE1opBf+8kvtQYpzQV6gwtlNaJYtCX6Enlt7UYdXolOQ7QihdZt/S6Z6e5ohsLQh4Gm1+0zoaDMLac/V8JqEz3f1nB6FlO0o4Nk2OYxZXXwU4UcU5JTp9snRYZ1jezbwxOykqUNUBY5bs5uHPipD/5tIkJalhtOClcSiJ6i4t3AT9Pv9Mln/0UhTvBaJN1JtR/9oONpkqIu9lTDe9spmPlZNqmhIJwYKIIlp4vuI0nkSRU/pxmV5t6+mU2rNYDn3Xkcq8y8/2wVpmH8b6yTsYHrV8KZpvzWLxI+XbjHo35ZeQnmnRbKEEot0Q7TqfZZKKSJM5shbFyv47tO0a0uby+Mr485F/vm97OZWKtNTa6Ve6rtCysZ99CbUzbv9DHF9SMIoMJPVPSKZ8qyOC0jAm4hsb+MJpKvr0XjwxZ5cOLeqpZdnQ/n5EZjOFy0hvKXIjhilw372QOhpMyI/xsz6o/uKTUqLsYKSPoZM7LVWOKo+lI7fvTs/leB7Pijp+Nej91JlKkgnR6dvf61SRIz6J0cnJ3Wqs9P3NaqT06saxfeeK5YqQfleApmvf/xZhEA6PTp9/076UWHniPzk6OSsKiLbdN5xl67jLx2arm+1bOYxDPMwDgR4yY4OQfgSYuHMQS0Ym5t7rUk19RKK/vuC2kT1wsA2ifhvD6yRXqWXyyNq+YNHUSBPYrm8VCBX410pvC8our1SQ3EU+SJ20/gQxsOQ/BSrhuP5T/FyH/w0Y+1Gxl62Tuy6VZZFpnSbiMsk3hLcunmW/ZkEFCKGcM9lAK7+UX9+ONiHWoQG5clnLXDbF1RKSv7qQ3aPITeOD3kfjPSIdu1R9rpZsDjXBd6DwMwaiX+1kG09N903ya6S9IVw/Zu3WkdoAFKO5z2fyquQz52+uDyBggXqx4hVLlfk/5fhzcNR/6j/9rz5Akb6ruXmBdft4OJqzCqJWLiOUMN9EPoaHhHgOHoSF164K1AcrHEYi9svjQ75O8aW2nhbUb3tw66cSK9bNMcL8T5VtLnSGwkortwSGgi1AMd9yDoEuEdL7yHEJD3iZ9nNnTTYGfVJn9dNJo6tt60MY2B4sYjSP20R926yLS3ABJaYzcNve1mDX/ejHgf0NmTLA+mNVHRh1c2sktoa8TSs82f7vP7mHR7lmQtHgo2bc/A58+bddlE4FFdvPIIcXCH7ibtdh2Ihq10G6DC55VpSwVrxzvV2UmwPg3ttIfYECbClF/OQoP9JvPSo6CeGw/OJdd2wahhd/k9dsqa4joR+ZkQRojQdzn8yBJqCm58ZQsPCyZeb+oNfGuTspcw/vdS8YEnZXja2Zs92jwFyfQwbQ5KLxb6y7oun2TpeXdNBztboYrGuNTh1H/wt0DH3487QsVHC9llkeowrDn8UyYjn4vpZiGMvq0HVw/Syu9y8A1STIvrHPJsqSmh+kK18zg+BJvM5RexuMJgx38SPfQfP4vAbf1M9nM62ont+Wtf5a6Xhzpz09PT0JI/HchDA1dVgtRpQ2p/P51Ll5KEXeZTVrxLWHucH56DA0db465cNuRMkqeaFDeGbVxe3CSvqegdijz9cIbr2YpDT9G9RrXPMUHFH7c5Ww43JXs2EtsuTVYl7myvWllS5llKZH6szWIED5C9x/eFffOo+IMIcLP+T4jgLbXZzkT8BBX5PpVUg2hWmTNyBGIDUQ/HDID9zi/nDclJIo0oIBHE1Jk2EeQhqxMXDCkPWVVTHPNieVT/2pN+bhpS5ovqw2RUp878pjm0xgxvdUVzvFFY3hbNq+WSN0uEYQZW++rhCnTfRA5CO+8dH1Vc1x27kQ5VOL6pBGq/y1wpRxYkVr9SdmDqt4oy/BMzllVscM31vuYb8o/e9XnJ+9LmQvR//GwAA//9QSwcIF/u6NNcUAACSTQAAUEsDBBQACAAIAAAAAAAAAAAAAAAAAAAAAAAUAAAAd2luZG93cy9zZW5kbG9ncy5wczGsU09P204Qve+nmN+SQyL97NhBRIXWLTSlYJU/EYZKLeWwjSf2ivWutTt2WyG+e7U2IVBA6qF78sy8eTNvZvxmgwEAhNmXk9N5lmad5d9FrYzIHQhQpoDvjc4VAhmgEqE0jmBpLFgkK7EVClop4KBBR5+Pj0zhQtbTftjPZmfp/Dw9Pfm3zP6di2v0NLWwokJCC2YJAr6mc1hKhaBF1RE3XcH/4UcpFyVIBw41rSoeGkd7BWq6p/UFfWTcVl3gyBSAOq+N1BSyjbfsclblCum91LnUxXB0xboOhh3DpSMrdXHVGYO5oJKNGJNLGP43PEdHgXf1gdEIbjqYRWqsZreMDQ6MUBkJwj1bOEhgt0fwY6TS5DzhB0j8de+7sJInvCSqd8bjePoqnG6G8WQ7jKfjSixKqXH8bmGqOimMUM6TrjIPUeRoHU92b/jPoHJBi9ZJo3nCJ1E8CeI42Iz4Lbt90BAkMBimujXXGJyho74j2H3U8Si8Nxkb9Jt+Scm8+QslO5uTrcn0wSpWKan+KBXypJvkU1n323xG31YQbQdRfMe0Bi2URE3BwliLSpA0Wvo+X8L58+IJ3/uUzbL9uWoKqV+CrstHYRxGT2FGk5AarS+4Hnk4W/nXX2n+Z3JbCT8bZYogx1qZXxVq8kTDZ5nOjMJUOxJ6gUfS0SOHxy1l0dhO/p114v+jwNVKEvBvIR9dRv15+wN55iLWa/8dAAD//1BLBwiFX+NRIQIAAF4EAABQSwECFAAUAAgACAAAAAAAF/u6NNcUAACSTQAAHAAAAAAAAAAAAAAAAAAAAAAAd2luZG93cy93aW5kb3dzY3NlaGVscGVyLnBzMVBLAQIUABQACAAIAAAAAACFX+NRIQIAAF4EAAAUAAAAAAAAAAAAAAAAACEVAAB3aW5kb3dzL3NlbmRsb2dzLnBzMVBLBQYAAAAAAgACAIwAAACEFwAAAAA=" $global:KubeClusterConfigPath = "c:\k\kubeclusterconfig.json" $fipsEnabled = [System.Convert]::ToBoolean("false") diff --git a/pkg/agent/testdata/AKSWindows2019+ManagedIdentity/CustomData b/pkg/agent/testdata/AKSWindows2019+ManagedIdentity/CustomData index 1318ae7a47e..d93c4bf788b 100644 --- a/pkg/agent/testdata/AKSWindows2019+ManagedIdentity/CustomData +++ b/pkg/agent/testdata/AKSWindows2019+ManagedIdentity/CustomData @@ -193,7 +193,7 @@ $global:TLSBootstrapToken = "" $global:IsDisableWindowsOutboundNat = [System.Convert]::ToBoolean("false"); # Base64 representation of ZIP archive -$zippedFiles = "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" +$zippedFiles = "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" $global:KubeClusterConfigPath = "c:\k\kubeclusterconfig.json" $fipsEnabled = [System.Convert]::ToBoolean("false") diff --git a/pkg/agent/testdata/AKSWindows2019+SecurityProfile/CustomData b/pkg/agent/testdata/AKSWindows2019+SecurityProfile/CustomData index e3de122c2db..91e1f359965 100644 --- a/pkg/agent/testdata/AKSWindows2019+SecurityProfile/CustomData +++ b/pkg/agent/testdata/AKSWindows2019+SecurityProfile/CustomData @@ -193,7 +193,7 @@ $global:TLSBootstrapToken = "" $global:IsDisableWindowsOutboundNat = [System.Convert]::ToBoolean("false"); # Base64 representation of ZIP archive -$zippedFiles = "UEsDBBQACAAIAAAAAAAAAAAAAAAAAAAAAAAcAAAAd2luZG93cy93aW5kb3dzY3NlaGVscGVyLnBzMdR8XXebuNb/fT6FFvH/NFlT3Lw06dSz+K+hmCSc2OAFOGlPm8UQkG2dYuRHEkkznX73Z0mINxsTp2eei9OLxIH9pr23tvZPkrsP/AWigEYErRhAFGQUxoBhEMMZSiG4DymKQMZQAmZZGjGEU7q3DyxBew8Zg6RGXZIAlAK2gFIuBVkaQwIoC+conb+JKHzziNIYP9L+3t4+GObcYZIA+A0xEOEYChG3OREwPDNXuswoA8uQRQvwx2dd/Vdw98sfe715gu/DZHBr2UPn1gsMzwy8qWGYnqcdtb41Xddxg6l9bTu3tnYM9sEFJiBL4bcVjBiMASQEExCF2XzBwP2TGEsk1N4nOPrKbfua3UOSQgapHAqFLFv1V/S4Q+XQubVHjj4MLqyRGdxa/lXgmr77STvpYLLsG+faDMyPpjH19Q8jUzvtoBaSbccPzI+W52tvO0iNK9O4DvSJFXime2O6geHYtmn41o3lf9LOOjgn+tQzA2usX9Z1nXdwXJp+4E0/2KYfTFzzwvqoveuktk1X983Ad65NO7hw3EB3x9qvHSy26d867nVg2b7pXuiG6dUse78Doz7UJ77p1riOu7JnrNv6pTk2bT+wJnWmrvgb+sgyHOFuyzAD3TCcqe3XubsSwXBsX7ds0x0KDsv2fH00MofacVdCrHG5U9u27EvtuCsznIlpe97VupqulChYLizXvNVHI8FrOPaFdTl1OXNXdlj2jT6yhsFEd/WxyaNg2YH+r6lrShHacVe62E4wdIxr0w18J/gwtUZDmaHl2LXjrtzhyWnogWG6vnVhGbpvetpxV86U83id66QrZczxxP+0ydKVMKbNJ3zgmQb3hT/ytJOuDLkce3pgfpzo9jDQXePKujG1k67kyBlyJRPn1nS9K3M0CiaudWONzEtTO+lKE8HtmX7gmpeW57ufgonpji3PsxxbO+nKlk3OG3005d7oLCKcyxpPHNcPDOPSvDFt39NOOitJk0W/vplMRtNLyy6YO2uK4wcXztQeNme7dtJZT0qmPBPt6fiD6WqnXZlR8Uxc58bi/rPsy8AzXGvie9ppV4p4vu7yEjI0A9fkLs25Al/3rrXTrmypstgzg4luXOuXpnbalS4lx/X0g+napm96FWNXplSqbKvi6MqQkuPK9oKxM5zyda8rOWpzUhTZUktXepRMIk9Klq6kqHnN4uH6+Kni261mVAW5YHzblRw8pr4xCYafbH1sGYHIZVe3OV9XYuTpJwvjej1825UYkymvAdUar73tSopcj69fNlk6O4/KBR8sW3c/Fd1KV0YUfjA/GqPp0Gz4oSsxON902O6/rtwo+Nr0dVeNwJh6vjMOhrqv8wFqb9+DfeBClhHeFyNaNJg4hryXjCiMljHvHcHjAqbAGHzR/8wIHIYs/GJklOEl/9i/RymIMaQgxYy3ypQ9Y4YnasJ05Acj51I7O/oPrPBMF9IsYf0Ez3c3wnAmn7juwHBGI95aOnZZ1c66ktc1PetfZuB4wdDlq9hZ57I3meZkbtGt6ELThW7xvuWscwXcwutbY9OZ+tpZ5wK4hflmHAjzeV33phOeOdyOzhVxi6ipm7dSnulrZ52L42QaeNfTwLIvnGpB0c46V8ctSiucolujqWtqZ53tU11K3sh51qWt+4KzqyZu029+NMwJ/6Sdd1XG53xmfjS1864sm06Gus9XWr6eBcZo6vk5DOIt53lnyplyzbUmN+e8JzjvTDLTr9e8G9MVLdL5Ww5/JwkMKQRhHIMUPtYn5QwTEOPHNMFhjNK5eL0Ko6/hPMfH7iSnYxiXyk3ObuAY2uESUqCB3w/2AABAqVsl4bHyevOVdEyOjbcTbEOy2zk2YOx20iaG3U7XCWC3s7Wi1+3kG9C1i7QNt26n7wKtz3NtINbtLFvQaodrn0GqHZxbUOrOHBKhbqdvRafPk29Bpp0Z241KO0L0LCLtzrc1kLjDPNyZoxWFdpCvI9AOwzfR53PE25HnM5xbUOdLuHLE+QzHOtrcmXwdaXblSivK3IWhjjB3oW9Dl9v5upDlLhlZocodqDcR5Q5MNTS5A3WFJHcgbqLIHRjqCHIH8g30uAvPBnLsCN5W1LidpwsxbudaR4vPyV9DijutC3WU+PyYNxFbN087Onye5yV6NlFhN20DunX5aCvA2s60Bq46alonsHo5nwRVL2dsBVQvF1MDU93Mm0Dq5crWQdSOEtYA1I5cbeDp5aw14LSduQs0dahcA0zdlJtgSdk75GDJdnxzAK7Lw7cbSCjCtW2RCKcsRClQHpQSE41RipZhssF1i9hiFDJImZFzQRIDDSjH/ZNf+0cK2Ae3KElAtAjTOQSIAYbzo0BMCIwYeJDKxXbJIwQ0W60wYQKnFWeXUSVZku/tg6E5cU3eeA0HwBcCU4ZCQSTxHchIAh659nsIKGQc7unXXgH5+uAW5q8JXOIHKMya4STBjxwoPoQEhfcJLA9iZxnLCOyXHvEYf12NeiK1akB5OO6f90+O1fBPznH85h6lIUGQvqlGoq7RqPIIVA2X8fnbPgtJf/6nsrcvxpYIB7f5oTBmPQRNY9713z9nS41kiykVPH6AKaMjPJ+jdD5EhCsxBl9ktMR+15cRntMvkySbo5R+GaOIYIpnrG/g5SpjsJ9vyHniaNv8xmDKB/MlF/ylSjo/pF85Bucamk99tIQeC5er/NWePISfoYRBIgNKQZrlqUfCiEFCwcGXo0PwuEDRAoQEgihc8ZDGPMIppcs+/AYBztgqY3k+Jng+hzFgC4Kz+QKs8CMkdAGTZE8qcoUiO0sSCr6DXgBUAldJGEHw6svRq9fg1SvwY68g5jZTYfN3oPQOLiFThyGDQL3AZBkygA8HoBcogkPeAgC3BDGojvD8oLeElIZzeAi+i1nfW9I50EDxGPxVyRfvc04nHw0n3qvLHcotkQuUQOcBkivGVlLwJCThMt/w4P8+i78hg+RgHKZxyDB54noZyeDh3WfKCErndyV5b0qS1z/NPISUoTTkJk5CtthZEEpZTYr5DTEDx1A8OdwTv/bBBSJ8Di1g9JUXIQohQDMQ8pzhdYAt8usWPN1S/gNRECYEhvETiMJoAWOA80JwczXMI8A5ZXp+tpw+t/huMLiE7EK+OODekAb0KAxJtBC7SYfiCZqBAx9SpnJGUGS3wXUNESni3OTleoaIV05Mnipl9GCd/XVl3mvB5QkRzor79m4w0JOkkIMgzQ36sVfaJTX2DZylDKgpBEd1g8q0BMqU8mopPVRUczyreUcFBl49cSrh6hnBS9ArNHw+ujvk4VgPvVLq4syqxeASSEeVjECtMW1IEPMqgnJk/CdMKGx6NcoInBDMcIQTWguNeI3SNoLP3hNlcNm3Iet7/D1iTwWF/7SCd4NBTjGEszBL2GuwCwdNTmWe8H8zTGAYLcBBbyXpeIkq5JhptsxDfxMmGaTPm3RYjx0oQrw5PjXFTC4LFJS615lbffeLVjE0qH/sbX5qGkweUAQnGKVsHKbhHBLukLVh8Lm+prJyVw8n8YTgOYGUTgicQQLTiM/K3ubTiqmV45WHEpiy5IkvpSjN4KuammIfmRdavuoVwxiicJ5iylBE+x7Dq8eQRbwSeCwkzIaPtaRi5GnNm72QzEVmfZ8SpPGC8RsYQ7bAsaZcQqb8BpxMzHFtPcF/NOS4kJEn1cDLZZjGoPygWOkD/gpVF1KWi1WAqnOVuWKV8yFIwVn+8WkIk/DJgxFOYwqOj6roydtbTes9yNSi3ILqU6/2jBBMxnKRUi5ClOQLbn1Tno+6DwSlWAJbUqbpfOHmg9qMEQktS6C+WlkpRfMFo0aCoKxfPd4MrKdyD/KWA2jAho+qc/9v3pEqVbuir1YJioTDC4n9YchCnhy8p6B90bL4MIFL7julRXi/aGB4DItlt5VwQvAKEoYg/awUK4hyx9O4KKVtXGMev4h+VoYZEZaOac7UdJiZhCsK4zFKEkTz6DalbXNe3ydh9FWM8yBXeVgLzzPTqX1mti0jhWdgnK8SPCW2rws/Gs1MPQn3dm5itO7mobv30La2MPV8F09zd9WG6kEGyvnBh1j+wScs/IZYNRfq0vKhl124ZNKa7c4+B1EZ5f1gSPOOBq5Cwo3mD0LwiMnXkOAsjQFFPEoKwAS8AjEW2I+/5oTlPc4VJEIME3GY06YRNfO0g4a19Vb4L94K/793xqvcF+KGamV2PZQTTNkKp3m9CgmTgIEAGVeOK1QfqyIfgVoCBEW/9voSgRie2S/krIlRcpayHIkKzWMQEchb8TAFXDlDSwhYSEWjSHIRees3lkEIc3PzwuHx3idLYMxl6/kb1fwGo4xBoFSogeOLvPpmS26+UpXpPxRpqVqOOG9f/lCkxhVBaYRWYdKmdFK+VKcUEisG3ifPN8eAZxxOeRMA5EKrR1He07lZOoIPMAFXaL6AlMn0YQTN5yLmiOY+wMWU7RXvcgv+ie99+UDVGQAlojns63Esl5CD47NDXjMhL0NAdUpZ4r4z2uZFoEo/Fp5WqyHWXKEWBpSm8ZZQwErOVDgVRIVTwxn/uSL4AfFGlS8+9bi6cI4og2TdmCrPZDaoUZVRVrrKmFw8asNan/aGSLF4pxyrT4mcTy27/p+ocBtF6iJLkucBltabhQltB2qFNVMqtxnmMIUkTMAqIytMZbHK57v4wVdo1casgXkKOw63gIt87CAutFUc4mB/zYxqVeX5lEMG/lOkf0kK1nSD/5/3BvnCsg4S6kvUblbkF3pobaHaBwvGVnTw5g1lYfQVP0AyS/BjP8LLN+Gb07dnZ+/Pzt6+OX//7vjkvAo8H4QPlytMQvJUKZfwfxWSvHUputAGAuV8/C/ZehYBBL1U4lXJdJmh+G4wsOEj/ySpd/DewT8xSqUjpSVC9GEjdZs96c55WwP2N2GC4pBBGzM7SxKHmMsVezpoS0mpZuc9g+2iFyFdiM29mnTeMv8Nopu9huy9/0/kNhp5ORnFL56yBz0ENHD0G/gN1GfeJjrZB8O8L0jwHAjYkDcN4uMyfCr3iilMKWLoAYI4ZGFDRm0KCcNAD4EB6EV5vJqtMMmv1v2jDCf4nasqaSpA0IZGeuiXXxoPcpwL1Dksnd2GZtmC4EfQCxovmvBKdAqql0C42ubfiqnZnkoEljcEPK12nwkdbWYp7bka3pDw+a6Z0yNE2Y4Cnm2TUcqa4pMEP8K4oMy3T44Omxybs4EnZidNE6Jq4HhrdvPQJ1XofxMJsmWp4bTAzVLRE9TcW7oJ9Pv9Kln/0UpTvhaJN9I93/xo+YYzNMXeCko3vbKej3WTahryiQFjkKU0iyJI6SxLkqd847L8yhdo6FS2ZrBaeK8jlfm/SO6CtMy/tXUS7GB63fC2ab8xi8Svl24xmN8WYUZ5p0VkQolFuiVazT5LpxQSpnLkbYoVfPdp2rWlzeXxlXHnIv/8XnZ7KyX1NFqpl/qulLJ2PbkNdfNuXyKuDxlKYjtb3kMilcs6LiABbyLk3sYTUK6uR+PBF8+58G9116zOhorzI2D7X4yM8JZCHjEqh335QOjZZkRxjCn7o/uaTdoWYwUlfURM7LXWOOo+VI7fvTs/VcD3YlDK8a9H75XaVFBOjk7f/lqnSBiNTo5OTppUZ6fvG1Qnp1cNiu+9QCxVgvK9AlS+/vFnCQTK6dHp+3fKjxo7R+QnRydndRFy03nHXbqOi+9t16O2bOYxDGYojQV4kUeHQPgSpMKZg0Yw1jf3tibVJMwo/O8LahvVCwPbJuK/PbBWSlmYJGp1RK1+CCmMVSdVq0sFaj3etcL7gqLbqzSUR5EvYretDygdIvJTrAZOZz/Fy33w04yNGxl7cp3YdatMRqZym4iLk24I3rp5hnIJoBQxBPdcBsD173gXh4N90IjQoDr5bARu84JKRclffZD3GArj+JD3gZUf0a5Cyl63CxbnuoD3IGDqjsQ37+XWc9t9E3mVpC+Em9/C5SqBA6AUeD6MqLpEfO70xeUJGM9hP4Wsdrmi+Jr+m4ej/lH/7Xn7BYz83ZabF1y3j8urMcssYWiVwJb7IPQ1eIQAp8mTuPDCXQHTeIVRKm6/tDrk7xhbbuNtTfWmD7tyIr9u0R4vyPtU0eYqbxRAce2W0ECoBeC4D2SHAO7hInxAmORH/Eze3MmDLalP+rxuMnFsvWklSgHD83mSf3VE3LuRW1oAE7DAbIa+7ckGv+lHM43pLWKLA+WNUnZh9c2sitod8TRs8st93mj9Do/2zIUjwcbNOfgsvXm3WRQOxdWbkEAf18h+4m7XoVjIGpcBOkzeci2pZK1553ozKTaHwb02F3uCBLBFmPKQwP/Jwvyo6CeGw/OJdd2wahld8X98yKa4iYR+ZkQJpDQfzn8yBJqDm58ZQsvCyZeb5oNfWuTs5cw/vdS8YEnZXDY2Zs9mjwHU5hjWhqSWi31t3RdP5TpeX9OBKtfocrFuNDhNH/wt0LHw487QsVXC5llkfowrDn80xUpn4voZwmkoa1D9ML3qLtfvADWkiP6xyKaaElocZGufi0MgZzajkN0NBlMW2fix7+Npir7xN/XDabkV3Yvyus5fay135pSnp6cndTxW4xhcXQ2WywGl/dlsptROHnpJSFnzKmHjcXFwDjRwtDH+5mVD7gRFaXhhTfj61cVNwpq63oHY40dLSFdhCtQ8/beoNjlmqLmjcWer5cZkr2HCtsuTdYl76yvWhlS1kVLSj/UZrIEDGC1w8+FffOo+QMJ8rP6T4lSGVt5c5E+ABn7PpdUg2hWmTNyBGAClB9OHQXHmlvKH1aRQRrUQCOJ6TNoIixA0iMuHNQbZVdTHPNicVT/2lN/bhiRdUX/Y7oqc+d8Up56Ywa3uKK93Cqvbwlm33FnBfDhWXKevP65RF030ACjH/eOj+quGY9fyoU5nltUgj1f1Z42o5sSaV5pOzJ1Wc8ZfAubyyi2Omb5vuYb8o/e9WXJ+9LmQvR//GwAA//9QSwcIRDVWeWsUAAChSwAAUEsDBBQACAAIAAAAAAAAAAAAAAAAAAAAAAAUAAAAd2luZG93cy9zZW5kbG9ncy5wczGsU09P204Qve+nmN+SQyL97NhBRIXWLTSlYJU/EYZKLeWwjSf2ivWutTt2WyG+e7U2IVBA6qF78sy8eTNvZvxmgwEAhNmXk9N5lmad5d9FrYzIHQhQpoDvjc4VAhmgEqE0jmBpLFgkK7EVClop4KBBR5+Pj0zhQtbTftjPZmfp/Dw9Pfm3zP6di2v0NLWwokJCC2YJAr6mc1hKhaBF1RE3XcH/4UcpFyVIBw41rSoeGkd7BWq6p/UFfWTcVl3gyBSAOq+N1BSyjbfsclblCum91LnUxXB0xboOhh3DpSMrdXHVGYO5oJKNGJNLGP43PEdHgXf1gdEIbjqYRWqsZreMDQ6MUBkJwj1bOEhgt0fwY6TS5DzhB0j8de+7sJInvCSqd8bjePoqnG6G8WQ7jKfjSixKqXH8bmGqOimMUM6TrjIPUeRoHU92b/jPoHJBi9ZJo3nCJ1E8CeI42Iz4Lbt90BAkMBimujXXGJyho74j2H3U8Si8Nxkb9Jt+Scm8+QslO5uTrcn0wSpWKan+KBXypJvkU1n323xG31YQbQdRfMe0Bi2URE3BwliLSpA0Wvo+X8L58+IJ3/uUzbL9uWoKqV+CrstHYRxGT2FGk5AarS+4Hnk4W/nXX2n+Z3JbCT8bZYogx1qZXxVq8kTDZ5nOjMJUOxJ6gUfS0SOHxy1l0dhO/p114v+jwNVKEvBvIR9dRv15+wN55iLWa/8dAAD//1BLBwiFX+NRIQIAAF4EAABQSwECFAAUAAgACAAAAAAARDVWeWsUAAChSwAAHAAAAAAAAAAAAAAAAAAAAAAAd2luZG93cy93aW5kb3dzY3NlaGVscGVyLnBzMVBLAQIUABQACAAIAAAAAACFX+NRIQIAAF4EAAAUAAAAAAAAAAAAAAAAALUUAAB3aW5kb3dzL3NlbmRsb2dzLnBzMVBLBQYAAAAAAgACAIwAAAAYFwAAAAA=" +$zippedFiles = "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" $global:KubeClusterConfigPath = "c:\k\kubeclusterconfig.json" $fipsEnabled = [System.Convert]::ToBoolean("false") diff --git a/pkg/templates/templates_generated.go b/pkg/templates/templates_generated.go index 15c3343f690..09efc547ea4 100644 --- a/pkg/templates/templates_generated.go +++ b/pkg/templates/templates_generated.go @@ -9059,6 +9059,9 @@ $global:WINDOWS_CSE_ERROR_GPU_DRIVER_INSTALLATION_URL_NOT_EXE=61 $global:WINDOWS_CSE_ERROR_UPDATING_KUBE_CLUSTER_CONFIG=62 $global:WINDOWS_CSE_ERROR_GET_NODE_IPV6_IP=63 $global:WINDOWS_CSE_ERROR_GET_CONTAINERD_VERSION=64 +$global:WINDOWS_CSE_ERROR_INSTALL_CREDENTIAL_PROVIDER = 65 # exit code for installing credential provider +$global:WINDOWS_CSE_ERROR_DOWNLOAD_CREDEDNTIAL_PROVIDER=66 # exit code for downloading credential provider failure +$global:WINDOWS_CSE_ERROR_CREDENTIAL_PROVIDER_CONFIG=67 # exit code for checking credential provider config failure # Please add new error code for downloading new packages in RP code too $global:ErrorCodeNames = @( @@ -9126,7 +9129,10 @@ $global:ErrorCodeNames = @( "WINDOWS_CSE_ERROR_GPU_DRIVER_INSTALLATION_URL_NOT_EXE", "WINDOWS_CSE_ERROR_UPDATING_KUBE_CLUSTER_CONFIG", "WINDOWS_CSE_ERROR_GET_NODE_IPV6_IP", - "WINDOWS_CSE_ERROR_GET_CONTAINERD_VERSION" + "WINDOWS_CSE_ERROR_GET_CONTAINERD_VERSION", + "WINDOWS_CSE_ERROR_INSTALL_CREDENTIAL_PROVIDER", + "WINDOWS_CSE_ERROR_DOWNLOAD_CREDEDNTIAL_PROVIDER", + "WINDOWS_CSE_ERROR_CREDENTIAL_PROVIDER_CONFIG" ) # NOTE: KubernetesVersion does not contain "v" From a04290aeefe15607c8b938ae5a9645222d5f2cf6 Mon Sep 17 00:00:00 2001 From: Qingchuan Hao Date: Tue, 16 Apr 2024 03:10:58 +0000 Subject: [PATCH 11/13] remove debug code and ensure flag key --- staging/cse/windows/configfunc.ps1 | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/staging/cse/windows/configfunc.ps1 b/staging/cse/windows/configfunc.ps1 index 4fda8eb5646..b8a7ccbc0c7 100644 --- a/staging/cse/windows/configfunc.ps1 +++ b/staging/cse/windows/configfunc.ps1 @@ -407,15 +407,13 @@ function Validate-CredentialProviderConfigFlags { $credentialProviderConfigPath = "" $credentialProviderBinDir = "" ForEach ($kubeletConfigArg in $global:KubeletConfigArgs){ - if ($kubeletConfigArg -like "--image-credential-provider-config*") { + if ($kubeletConfigArg -like "--image-credential-provider-config=*") { $credentialProviderConfigPath=get-KubeletFlagValue -KubeletConfigArg $kubeletConfigArg } - if ($kubeletConfigArg -like "--image-credential-provider-bin-dir*") { + if ($kubeletConfigArg -like "--image-credential-provider-bin-dir=*") { $credentialProviderBinDir=get-KubeletFlagValue -KubeletConfigArg $kubeletConfigArg } } - echo $credentialProviderConfigPath - echo $credentialProviderBinDir # Both flags should be set to enable out of tree credential provider or not set at the same time to disable it. if ([string]::IsNullOrEmpty($credentialProviderConfigPath) -xor [string]::IsNullOrEmpty($credentialProviderBinDir)) { From 3c1b1adf32ad301594e9efcd5fb29781be501297 Mon Sep 17 00:00:00 2001 From: Qingchuan Hao Date: Tue, 16 Apr 2024 11:19:45 +0800 Subject: [PATCH 12/13] remove unused test --- staging/cse/windows/configfunc.tests.ps1 | 6 ------ 1 file changed, 6 deletions(-) diff --git a/staging/cse/windows/configfunc.tests.ps1 b/staging/cse/windows/configfunc.tests.ps1 index c8285fff935..d4cb5764a82 100644 --- a/staging/cse/windows/configfunc.tests.ps1 +++ b/staging/cse/windows/configfunc.tests.ps1 @@ -198,11 +198,5 @@ Describe 'Validate-CredentialProviderConfigFlags' { $credentialProviderConfigs = Validate-CredentialProviderConfigFlags Assert-MockCalled -CommandName "Set-ExitCode" -Exactly -Times 1 -ParameterFilter { $ExitCode -eq $global:WINDOWS_CSE_ERROR_CREDENTIAL_PROVIDER_CONFIG } } - It "Should call Set-ExitCode when flag value is emtpy" { - $expectedCredentialProviderBinDir="c:\var\lib\kubelet\credential-provider" - $global:KubeletConfigArgs+="--image-credential-provider-bin-dir" - $credentialProviderConfigs = Validate-CredentialProviderConfigFlags - Assert-MockCalled -CommandName "Set-ExitCode" -Exactly -Times 1 -ParameterFilter { $ExitCode -eq $global:WINDOWS_CSE_ERROR_CREDENTIAL_PROVIDER_CONFIG } - } } } \ No newline at end of file From 159e9115fd3b1bad35e699d945025fedd2a23a23 Mon Sep 17 00:00:00 2001 From: Qingchuan Hao Date: Tue, 16 Apr 2024 12:05:44 +0800 Subject: [PATCH 13/13] use global var instead of returing two var in func --- staging/cse/windows/configfunc.ps1 | 24 +++++++++++------------- staging/cse/windows/configfunc.tests.ps1 | 16 ++++++++-------- 2 files changed, 19 insertions(+), 21 deletions(-) diff --git a/staging/cse/windows/configfunc.ps1 b/staging/cse/windows/configfunc.ps1 index b8a7ccbc0c7..f7d5cd5898e 100644 --- a/staging/cse/windows/configfunc.ps1 +++ b/staging/cse/windows/configfunc.ps1 @@ -404,14 +404,12 @@ function Validate-CredentialProviderConfigFlags { } return $splitResult[1] } - $credentialProviderConfigPath = "" - $credentialProviderBinDir = "" ForEach ($kubeletConfigArg in $global:KubeletConfigArgs){ if ($kubeletConfigArg -like "--image-credential-provider-config=*") { - $credentialProviderConfigPath=get-KubeletFlagValue -KubeletConfigArg $kubeletConfigArg + $global:credentialProviderConfigPath=get-KubeletFlagValue -KubeletConfigArg $kubeletConfigArg } if ($kubeletConfigArg -like "--image-credential-provider-bin-dir=*") { - $credentialProviderBinDir=get-KubeletFlagValue -KubeletConfigArg $kubeletConfigArg + $global:credentialProviderBinDir=get-KubeletFlagValue -KubeletConfigArg $kubeletConfigArg } } @@ -419,7 +417,6 @@ function Validate-CredentialProviderConfigFlags { if ([string]::IsNullOrEmpty($credentialProviderConfigPath) -xor [string]::IsNullOrEmpty($credentialProviderBinDir)) { Set-ExitCode -ExitCode $global:WINDOWS_CSE_ERROR_CREDENTIAL_PROVIDER_CONFIG -ErrorMessage "Not all credential provider flags are configured: --image-credential-provider-config=$credentialProviderConfigPath, --image-credential-provider-bin-dir=$credentialProviderBinDir" } - return $credentialProviderConfigPath, $credentialProviderBinDir } function Install-CredentialProvider { @@ -433,9 +430,10 @@ function Install-CredentialProvider { try { # Out of tree credential provider is turned on as a must after 1.30, and is optinal in 1.29, for cluster < 1.29, it's not enabled. # And only when it's enabled, the credential provider flags are set. - $credentialProviderConfigs=Validate-CredentialProviderConfigFlags - $credentialProviderConfigPath, $credentialProviderBinDir = $credentialProviderConfigs[0], $credentialProviderConfigs[1] - if ([string]::IsNullOrEmpty($credentialProviderConfigPath) -and [string]::IsNullOrEmpty($credentialProviderBinDir)) { + $global:credentialProviderConfigPath = "" + $global:credentialProviderBinDir = "" + Validate-CredentialProviderConfigFlags + if ([string]::IsNullOrEmpty($global:credentialProviderConfigPath) -and [string]::IsNullOrEmpty($global:credentialProviderBinDir)) { Write-Log "Out of tree credential provider is not enabled" return } @@ -443,18 +441,18 @@ function Install-CredentialProvider { Logs-To-Event -TaskName "AKS.WindowsCSE.Install-CredentialProvider" -TaskMessage "Start to install out of tree credential provider" Write-Log "Create credential provider configuration file" - Config-CredentialProvider -KubeDir $KubeDir -CredentialProviderConfPath $credentialProviderConfigPath -CustomCloudContainerRegistryDNSSuffix $CustomCloudContainerRegistryDNSSuffix + Config-CredentialProvider -KubeDir $KubeDir -CredentialProviderConfPath $global:credentialProviderConfigPath -CustomCloudContainerRegistryDNSSuffix $CustomCloudContainerRegistryDNSSuffix - Write-Log "Download credential provider binary from $global:CredentialProviderURL to $credentialProviderBinDir" + Write-Log "Download credential provider binary from $global:CredentialProviderURL to $global:credentialProviderBinDir" $tempDir = New-TemporaryDirectory $credentialproviderbinaryPackage = "$tempDir\credentialprovider.tar.gz" DownloadFileOverHttp -Url $global:CredentialProviderURL -DestinationPath $credentialproviderbinaryPackage -ExitCode $global:WINDOWS_CSE_ERROR_DOWNLOAD_CREDEDNTIAL_PROVIDER tar -xzf $credentialproviderbinaryPackage -C $tempDir - Create-Directory -FullPath $credentialProviderBinDir - cp "$tempDir\azure-acr-credential-provider.exe" "$credentialProviderBinDir\acr-credential-provider.exe" + Create-Directory -FullPath $global:credentialProviderBinDir + cp "$tempDir\azure-acr-credential-provider.exe" "$global:credentialProviderBinDir\acr-credential-provider.exe" # acr-credential-provider.exe cannot be found by kubelet through provider name before the fix https://github.com/kubernetes/kubernetes/pull/120291 # so we copy the exe file to acr-credential-provider to make all 1.29 release work. - cp "$credentialProviderBinDir\acr-credential-provider.exe" "$credentialProviderBinDir\acr-credential-provider" + cp "$global:credentialProviderBinDir\acr-credential-provider.exe" "$global:credentialProviderBinDir\acr-credential-provider" del $tempDir -Recurse } catch { Set-ExitCode -ExitCode $global:WINDOWS_CSE_ERROR_INSTALL_CREDENTIAL_PROVIDER -ErrorMessage "Error installing credential provider. Error: $_" diff --git a/staging/cse/windows/configfunc.tests.ps1 b/staging/cse/windows/configfunc.tests.ps1 index d4cb5764a82..1a7e1027e44 100644 --- a/staging/cse/windows/configfunc.tests.ps1 +++ b/staging/cse/windows/configfunc.tests.ps1 @@ -145,6 +145,8 @@ Describe 'Config-CredentialProvider' { Describe 'Validate-CredentialProviderConfigFlags' { BeforeEach { $global:KubeletConfigArgs = @( "--address=0.0.0.0" ) + $global:credentialProviderConfigPath = "" + $global:credentialProviderBinDir = "" } BeforeAll{ @@ -163,19 +165,17 @@ Describe 'Validate-CredentialProviderConfigFlags' { $expectedCredentialProviderBinDir="c:\var\lib\kubelet\credential-provider" $global:KubeletConfigArgs+="--image-credential-provider-config="+$expectedCredentialProviderConfigPath $global:KubeletConfigArgs+="--image-credential-provider-bin-dir="+$expectedCredentialProviderBinDir - $credentialProviderConfigs = Validate-CredentialProviderConfigFlags - $actualCredentialProviderConfigPath, $actualCredentialProviderBinDir = $credentialProviderConfigs[0], $credentialProviderConfigs[1] - Compare-Object $actualCredentialProviderConfigPath $expectedCredentialProviderConfigPath | Should -Be $null - Compare-Object $actualCredentialProviderBinDir $expectedCredentialProviderBinDir | Should -Be $null + Validate-CredentialProviderConfigFlags + Compare-Object $global:credentialProviderConfigPath $expectedCredentialProviderConfigPath | Should -Be $null + Compare-Object $global:credentialProviderBinDir $expectedCredentialProviderBinDir | Should -Be $null } It "Should return empty config path and bin path" { $expectedCredentialProviderConfigPath="" $expectedCredentialProviderBinDir="" - $credentialProviderConfigs = Validate-CredentialProviderConfigFlags - $actualCredentialProviderConfigPath, $actualCredentialProviderBinDir = $credentialProviderConfigs[0], $credentialProviderConfigs[1] - Compare-Object $actualCredentialProviderConfigPath $expectedCredentialProviderConfigPath | Should -Be $null - Compare-Object $actualCredentialProviderBinDir $expectedCredentialProviderBinDir | Should -Be $null + Validate-CredentialProviderConfigFlags + Compare-Object $global:credentialProviderConfigPath $expectedCredentialProviderConfigPath | Should -Be $null + Compare-Object $global:credentialProviderBinDir $expectedCredentialProviderBinDir | Should -Be $null } }