Dela via

Överväganden för att köra Azure CLI i ett PowerShell-scriptspråk

Azure CLI är ett verktyg för att hantera Azure-resurser genom Azure CLI-referenskommandon som körs i både Bash- och PowerShell-skriptspråk. Det finns dock små syntaxskillnader i parameterformatering mellan skriptspråk som kan resultera i oväntade resultat. Syftet med denna artikel är att hjälpa dig att lösa syntaxfel i Azure CLI när du arbetar i ett PowerShell-skriptspråk.

I den här artikeln jämförs syntaxskillnaderna mellan Azure CLI-kommandon som körs på följande skriptspråk:

  • Bash som körs i ett Linux-operativsystem med Azure Cloud Shell.
  • PowerShell körs i ett Linux-operativsystem med Azure Cloud Shell.
  • Windows PowerShell körs i Windows 11 och använder terminalen PowerShell 5.
  • PowerShell körs i en Windows 11 med PowerShell 7-terminalen.

Om du inte har använt CLI tidigare kan det vara förvirrande att skilja mellan ett verktyg och ett skriptspråk . Hur du väljer rätt kommandoradsverktyg ger en bra jämförelse.

Förutsättningar

Denna artikel är avsedd för dig att läsa och lära dig. Men om du vill köra exemplen, välj fliken Prepare your environments för att installera de skriptspråk som används i denna artikel.

Viktigt!

När du har ett Azure CLI-skript som ger ett fel, överväg hur det skriptspråk du arbetar i tolkar Azure CLI-kommandosyntaxen.

Hantera blanksteg i Azure CLI-parametrar

I Azure CLI, när du behöver skicka en parametervärde som innehåller ett mellanslag, finns det skillnader i hur citattecken används mellan operativsystem och skriptspråk. I det här exemplet ska du använda az storage account list och byta namn på utgångskolumnerna med ett ord som innehåller ett mellanslag.

I det här exemplet, observera den enkla citatteckeninramningen ('...') med inbäddade dubbla citattecken ("..."). Detta exempel fungerar också i PowerShell på Linux.

az storage account list --query '[].{"SA Name":name, "Primary endpoint":primaryEndpoints.blob}' --output table

Om du vill lägga till ett filter ändras syntaxen. Notera hur detta exempel omsätter --query parametervärdet i dubbla citattecken ("...") och använder ett backslash (\) escape-tecken. Det här skriptet körs inte i PowerShell.

 az storage account list --query "[?creationTime >='2024-02-01'].{\"SA Name\":name,\"Primary endpoint\":primaryEndpoints.blob}" --output table

Om du just försökte köra filtersyntax i ett PowerShell-språk, fick du felmeddelandet argument --query: invalid jmespath_type value: "[?creationTime >=...". Men i Bash inom en Linux-miljö är din utdata liknande denna:

SA Name           Primary Endpoint
-----------       -----------------
msdocssa00000000  https://msdocssa000000000.blob.core.windows.net/

Skicka parametrar i en URL som innehåller en söksträng

Frågetecken i URL:er anger slutet på URL:en och början på en frågesträng. Här är ett exempel som öppnar steg 3 i Lär dig att använda Azure CLI:

/cli/azure/account?view=azure-cli-2020-09-01-hybrid.

"?view=azure-cli-2020-09-01-hybrid resulterar i den önskade versionen av Azure CLI-referensinnehållet."

När du kör Azure CLI-kommandon i ett PowerShell-skript, tillåter PowerShell att frågetecken är en del av ett variabelnamn. Detta kan skapa förvirring i parametervärden för Azure CLI.

Här är ett exempel från artikeln Använd Azure REST API :

Observera hur $containerRegistryName?api-version slår ihop utan att ge fel i Bash.

# Script for a Bash scripting language

# Variable block
let "randomIdentifier=$RANDOM*$RANDOM"
subscriptionId="00000000-0000-0000-0000-000000000000"
resourceGroup="msdocs-app-rg$randomIdentifier"
containerRegistryName="msdocscr$randomIdentifier"

# prior to this GET example, the resource group and container registry were created in the article.

az rest --method get --url https://management.azure.com/subscriptions/$subscriptionId/resourceGroups/$resourceGroup/providers/Microsoft.ContainerRegistry/registries/$containerRegistryName?api-version=2023-01-01-preview

Passera parametrar som innehåller ampersandsymbolen

Om du har ett scenario där du behöver skicka ett och-tecken i ett parametervärde, var medveten om att och-tecknet (&) tolkas av PowerShell. Du kan se detta hända genom att använda parametern --debug:

az "a&b" --debug

# output
'a' is misspelled or not recognized by the system.
'b' is not recognized as an internal or external command

Men om du använder samma test för att lägga till en tagg i en resursgrupp orsakar ett et-tecken i taggvärdet inget fel.

az group create --location eastus2 --name "msdocs-rg-test"
az group update --name "msdocs-rg-test" --tags "company name=Contoso & Sons"

# output
{
  "id": "/subscriptions/3618afcd-ea52-4ceb-bb46-53bb962d4e0b/resourceGroups/msdocs-rg-test",
  "location": "eastus2",
  "managedBy": null,
  "name": "msdocs-rg-test",
  "properties": {
    "provisioningState": "Succeeded"
  },
  "tags": {
    "company name": "Contoso & Sons"
  },
  "type": "Microsoft.Resources/resourceGroups"
}

Om du har ett scenario där et-tecknet i ett parametervärde orsakar ett fel, här är några lösningar:

# When quoted by single quotes ('), double quotes (") are preserved by PowerShell and sent
# to Command Prompt, so that ampersand (&) is treated as a literal character
> az '"a&b"' --debug
Command arguments: ['a&b', '--debug']

# Escape double quotes (") with backticks (`) as required by PowerShell
> az "`"a&b`"" --debug
Command arguments: ['a&b', '--debug']

# Escape double quotes (") by repeating them
> az """a&b""" --debug
Command arguments: ['a&b', '--debug']

# With a whitespace in the argument, double quotes (") are preserved by PowerShell and
# sent to Command Prompt
> az "a&b " --debug
Command arguments: ['a&b ', '--debug']

# Use --% to stop PowerShell from parsing the argument
> az --% "a&b" --debug
Command arguments: ['a&b', '--debug']

Passa parametrar som innehåller ett at (@) symbol

Det finns specialtecken i PowerShell, till exempel tecknet at (@), som är en splattingoperator i PowerShell. Lägg till en bakåtvänd apostrof ` före det speciella tecknet för att fly det. Du kan också omsluta värdet med enkla (') eller dubbla (") citattecken.

De följande tre exemplen kommer att fungera i PowerShell:

  • parameterName '@parameters.json
  • parameterName '@parameters.json'
  • parameterName "@parameters.json"

Det här exemplet kommer inte att fungera i PowerShell:

  • parameterName @parameters.json

Här är ett annat exempel i az ad app create-kommandot: Observera att det krävs dubbla citattecken ("...") runt JSON-filens namn i ett PowerShell-språkskript.

# Script for a PowerShell scripting language

az ad app create --display-name myTestAppName `
    --is-fallback-public-client `
    --required-resource-accesses "@manifest.json"

Passera parametrar som innehåller JSON

För komplexa argument som en JSON-sträng är bästa praxis att använda Azure CLI:s @<file>-konvention för att ladda från en fil för att kringgå tolkningen av skalet. För exempel på JSON-syntax för Bash, PowerShell och Cmd.exe, se Skillnader i citationstecken mellan skriptspråk - JSON-strängar.

Skicka parametrar som innehåller nyckel:värde-par.

Vissa Azure CLI-parameter värden, såsom Azure-resursetiketter, kräver nyckel:värde-par. Om din key eller value innehåller ett mellanslag eller ett specialtecken, är syntaxen för Bash och PowerShell inte alltid densamma.

För syntaxexempel för Bash, PowerShell och Cmd, se Skapa taggar för att öva på att citera skillnader i handledningen Lär dig använda Azure CLI. Det här handledningssteget ger exempel på följande nyckel:värde-par scenarier:

  • Utrymmen
  • tomma värden
  • Specialtecken
  • Variabler

symbol för att stoppa parsning

Stop-analys symbolen (--%), som introducerades i PowerShell 3.0, instruerar PowerShell att inte tolka inmatningen som PowerShell-kommandon eller -uttryck. När det stöter på en tecken för att upphöra med tolkningen, behandlar PowerShell de återstående tecknen i raden som en bokstavlig representation.

az --% vm create --name xxx

Felhantering för Azure CLI i PowerShell

Du kan köra Azure CLI-kommandon i PowerShell, som beskrivs i Välj rätt kommandoradsverktyg för Azure. Om du gör det, se till att du förstår felhantering i Azure CLI med PowerShell. Särskilt skapar inte Azure CLI undantag för PowerShell att fånga.

Ett alternativ är att använda $? automatiska variabeln. Denna variabel innehåller statusen för det senaste kommandot. Om det föregående kommandot misslyckas, har $? värdet $False. För mer information, se about_Automatic_Variables.

Följande exempel visar hur denna automatiska variabel kan fungera för felhantering:

# Script for a PowerShell scripting language

az group create --name MyResourceGroup
if ($? -eq $false) {
    Write-Error "Error creating resource group."
}

Kommandot az misslyckas eftersom det saknar den nödvändiga parametern --location. Det villkorade uttalandet finner att $? är falskt och skriver ett felmeddelande.

Om du vill använda nyckelorden try och catch, kan du använda throw för att skapa ett undantag för blocket try att fånga:

# Script for a PowerShell scripting language

$ErrorActionPreference = "Stop"
try {
    az group create --name MyResourceGroup
    if ($? -eq $false) {
        throw 'Group create failed.'
    }
}
catch {
    Write-Error "Error creating the resource group."
}
$ErrorActionPreference = "Continue"

Som standard fångar PowerShell endast avslutande fel. Det här exemplet ställer in den $ErrorActionPreference globala variabeln till Stop så att PowerShell kan hantera felet.

Det villkorliga uttrycket testar variabeln $? för att se om det föregående kommandot misslyckades. Om så är fallet, skapar nyckelordet throw ett undantag att fånga. catch-blocket kan användas för att skriva ett felmeddelande eller hantera felet.

Exemplet återställer $ErrorActionPreference till dess standardvärde.

För mer information om hur PowerShell-fel hanteras, se Allt du ville veta om undantag.

Aktivera flikkomplettering i PowerShell

Tab-komplettering, även kallad "Azure CLI-kompletterare", ger komplettering av inmatning för att ge tips, möjliggöra utforskning och snabba upp inmatning. Kommandonamn, kommandogruppsnamn, parametrar och vissa parametervärden kan automatiskt infogas i kommandoraden genom att trycka på tabbtangenten.

Tabbavslut är aktiverat som standard i Azure Cloud Shell och i de flesta Linux-distributioner. Från och med Azure CLI version 2.49 kan du aktivera tabbkomplettering för Azure CLI i PowerShell. Följ dessa steg:

  1. Skapa eller redigera profilen som lagras i variabeln $PROFILE. Det enklaste sättet är att köra notepad $PROFILE i PowerShell. För mer information, se Så här skapar du din profil och Profiler och körningsprinciper.

  2. Lägg till följande kod i din PowerShell-profil:

    Register-ArgumentCompleter -Native -CommandName az -ScriptBlock {
    param($commandName, $wordToComplete, $cursorPosition)
    $completion_file = New-TemporaryFile
    $env:ARGCOMPLETE_USE_TEMPFILES = 1
    $env:_ARGCOMPLETE_STDOUT_FILENAME = $completion_file
    $env:COMP_LINE = $wordToComplete
    $env:COMP_POINT = $cursorPosition
    $env:_ARGCOMPLETE = 1
    $env:_ARGCOMPLETE_SUPPRESS_SPACE = 0
    $env:_ARGCOMPLETE_IFS = "`n"
    $env:_ARGCOMPLETE_SHELL = 'powershell'
    az 2>&1 | Out-Null
    Get-Content $completion_file | Sort-Object | ForEach-Object {
        [System.Management.Automation.CompletionResult]::new($_, $_, "ParameterValue", $_)
    }
    Remove-Item $completion_file, Env:\_ARGCOMPLETE_STDOUT_FILENAME, Env:\ARGCOMPLETE_USE_TEMPFILES, Env:\COMP_LINE, Env:\COMP_POINT, Env:\_ARGCOMPLETE, Env:\_ARGCOMPLETE_SUPPRESS_SPACE, Env:\_ARGCOMPLETE_IFS, Env:\_ARGCOMPLETE_SHELL
}

  3. Om du vill visa alla tillgängliga alternativ på menyn lägger du till Set-PSReadlineKeyHandler -Key Tab -Function MenuComplete i din PowerShell-profil.

Se även

  • Last updated on