Megosztás a következőn keresztül:

Az Azure CLI PowerShell-szkriptelési nyelven való futtatásának szempontjai

Az Azure CLI egy olyan eszköz, amellyel Azure-erőforrások kezelhetők Bash- és PowerShell-szkriptelési nyelven futó Azure CLI-referenciaparancsokkal. A szkriptnyelvek közötti paraméterformázásban azonban enyhe szintaktikai különbségek vannak, amelyek váratlan eredményeket eredményezhetnek. A cikk célja, hogy segítsen megoldani az Azure CLI szintaxishibáit a PowerShell-szkriptelési nyelv használatakor.

Ez a cikk a következő szkriptnyelveken végrehajtott Azure CLI-parancsok szintaxisbeli különbségeit hasonlítja össze:

  • Linux operációs rendszeren futó Bash az Azure Cloud Shell használatával.
  • Linux operációs rendszeren futó PowerShell az Azure Cloud Shell használatával.
  • A Windows 11-ben futó Windows PowerShell a PowerShell 5 terminállal.
  • Windows 11-ben futó PowerShell a PowerShell 7 terminállal.

Ha még csak most ismerkedik a parancssori felülettel, az eszköz és a szkriptnyelv megkülönböztetése zavaró lehet. A megfelelő parancssori eszköz kiválasztása jó összehasonlítást biztosít.

Előfeltételek

Ez a cikk olvasásra és tanulásra szolgál. Ha azonban futtatni szeretné a példákat, válassza a lapot a Prepare your environments cikkben használt szkriptnyelvek telepítéséhez.

Fontos

Ha olyan Azure CLI-szkripttel rendelkezik, amely hibát okoz, gondolja át, hogy a szkriptnyelv, amelyben dolgozik, hogyan elemzi az Azure CLI parancs szintaxisát.

Szóközök megadása az Azure CLI paramétereiben

Az Azure CLI-ben, amikor egy szóközt tartalmazó paraméterértéket kell átadnia, az operációs rendszerek és a szkriptnyelvek közötti különbségek vannak. Ebben a példában használja a az storage account list parancsot, és nevezze át a kimeneti oszlopokat egy szóközt tartalmazó szóval.

Ebben a példában figyelje meg az egyetlen idézőjel ('...') burkolót beágyazott dupla idézőjelekkel ("..."). Ez a példa linuxos PowerShellben is működik.

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

Ha szűrőt szeretne hozzáadni, a szintaxis megváltozik. Figyelje meg, hogy ez a példa az --query paraméter értékét dupla idézőjelek ("...") közé helyezi, és fordított perjelet (\) használ. Ez a szkript nem fut a PowerShellben.

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

Ha csak powerShell-szkriptnyelven próbálta futtatni a szűrőszintaxisát, hibaüzenetet argument --query: invalid jmespath_type value: "[?creationTime >=..."kapott. Linux-környezeten belüli Bash esetén azonban a kimenet a következőhöz hasonló:

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

Paraméterek átadása lekérdezési sztringet tartalmazó URL-címben

Az URL-címek kérdőjelei az URL-cím végét és a lekérdezési sztring elejét jelölik. Íme egy példa, amely megnyitja a Learn 3. lépését az Azure CLI használatához:

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

Az ?view=azure-cli-2020-09-01-hybrid az Azure CLI referencia tartalmának a kívánt verzióját eredményezi.

Amikor Azure CLI-parancsokat hajt végre Egy PowerShell-szkriptnyelven, a PowerShell lehetővé teszi, hogy a kérdőjelek egy változónév részei legyenek. Ez zavart okozhat az Azure CLI paraméterértékeiben.

Íme egy példa az Azure REST API használata című cikkből:

Figyelje meg, hogy a $containerRegistryName?api-version Bashben hiba nélkül összefűz.

# 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

Az ampersand szimbólumot tartalmazó paraméterek átadása

Ha olyan forgatókönyve van, amelyben egy paraméterértékben meg kell adnia egy ampersand értéket, vegye figyelembe, hogy az ampersand (&) szimbólumot a PowerShell értelmezi. Ez a következő paraméterrel --debug látható:

az "a&b" --debug

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

Ha azonban ugyanezt a tesztet használja egy címke erőforráscsoporthoz való hozzáadásához, akkor a címke értékének amperje nem okoz hibát.

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"
}

Ha olyan forgatókönyve van, amelyben a paraméterérték amperei és értéke hibát okoz, az alábbiakban néhány megoldást talál:

# 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']

At (@) szimbólumot tartalmazó paraméterek átadása

A PowerShellnek vannak speciális karakterei, például az at (@) szimbólum, amely egy splatting operátor a PowerShellben. Adjon hozzá egy fordított aposztrófot ` a speciális karakter elé, hogy kivédje azt. Az értéket egyetlen (') vagy dupla (") idézőjelbe is csatolhatja.

Az alábbi három példa a PowerShellben fog működni:

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

Ez a példa nem működik a PowerShellben:

  • paraméterNév @parameters.json

Íme egy másik példa a az ad app create parancsban: Figyelje meg a PowerShell-szkriptnyelvben szükséges JSON-fájlnév körüli dupla idézőjeleket ("...").

# Script for a PowerShell scripting language

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

JSON-t tartalmazó paraméterek átadása

Összetett argumentumok, például JSON-sztringek esetén ajánlott az Azure CLI konvenciójával @<file> betölteni egy fájlból a rendszerhéj értelmezésének megkerülése érdekében. A Bash, a PowerShell és a Cmd.exeJSON-szintaxissal kapcsolatos példáiért lásd : A szkriptnyelvek közötti különbségek idézése – JSON-sztringek.

Kulcs:érték párokat tartalmazó paraméterek átadása

Egyes Azure CLI-paraméterértékekhez, például az Azure-erőforráscímkékhez kulcs:érték párokra van szükség. Ha az key vagy value szóközt vagy speciális karaktert tartalmaz, a Bash és a PowerShell szintaxisa nem mindig egyezik meg.

A Bash, a PowerShell és a Cmd szintaxissal kapcsolatos példáiért tekintse meg a Címkék létrehozása című témakört az Azure CLI-oktatóanyagban szereplő különbségek idézéséhez. Ez az oktatóanyag-lépés példákat ad a következő kulcs:értékpáros forgatókönyvekre:

  • terek
  • üres értékek
  • speciális karakterek
  • Változók

Stop-parsing szimbólum

A PowerShell 3.0-ban bevezetett stop-parsing szimbólum (--%) arra utasítja a PowerShellt, hogy ne értelmezze a bemenetet PowerShell-parancsként vagy -kifejezésként. Amikor stop-parsing szimbólummal találkozik, a PowerShell a sor többi karakterét konstansként kezeli.

az --% vm create --name xxx

Az Azure CLI hibakezelése a PowerShellben

Azure CLI-parancsokat futtathat a PowerShellben a Megfelelő Azure parancssori eszköz kiválasztása című cikkben leírtak szerint. Ha igen, győződjön meg arról, hogy ismeri az Azure CLI-hibakezelést a PowerShellben. Különösen, az Azure CLI nem hoz létre olyan kivételeket, amelyeket a PowerShell el tudna kapni.

Egy másik lehetőség az automatikus változó használata $? . Ez a változó a legutóbbi parancs állapotát tartalmazza. Ha az előző parancs sikertelen, $? értéke $False. További információért tekintse meg az *about_Automatic_Variables* témakört a éscímkék alatt.

Az alábbi példa bemutatja, hogyan működik ez az automatikus változó a hibakezeléshez:

# Script for a PowerShell scripting language

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

A az parancs meghiúsul, mert hiányzik a szükséges --location paraméter. A feltételes utasítás hamisnak találja, $? és hibát ír.

Ha a try és catch kulcsszavakat szeretné használni, a throw segítségével kivételt hozhat létre a try blokknak a kezelésére.

# 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"

Alapértelmezés szerint a PowerShell csak a megszüntetési hibákat rögzíti. Ez a példa úgy állítja be a $ErrorActionPreference globális változót, hogy Stop a PowerShell kezelni tudja a hibát.

A feltételes utasítás ellenőrzi a változót $? , hogy az előző parancs nem sikerült-e. Ha igen, a throw kulcsszó kivételt hoz létre, amit el lehet kapni. A catch blokk használható hibaüzenet írására vagy a hiba kezelésére.

A példa visszaállítja $ErrorActionPreference az alapértelmezett értékét.

A PowerShell-hibakezeléssel kapcsolatos további információkért lásd : Minden, amit tudni szeretne a kivételekről.

Lapkiegészítés engedélyezése a PowerShellben

A tabulátorkiegészítés, más néven "Azure CLI-kiegészítések" a bemenetek kiegészítését biztosítják, hogy tippeket adjanak, lehetővé tegyék a felderítést és felgyorsíthassák a bemeneti bevitelt. A tabulátorbillentyűvel automatikusan beszúrhatók a parancssorba a parancsnevek, a parancscsoportok nevei, a paraméterek és bizonyos paraméterértékek.

A tabulátorkiegészítés alapértelmezés szerint engedélyezve van az Azure Cloud Shellben és a legtöbb Linux-disztribúcióban. Az Azure CLI 2.49-es verziójától kezdve engedélyezheti az Azure CLI lapkiegészítését a PowerShellben. Kövesse az alábbi lépéseket:

  1. Hozza létre vagy szerkessze a változóban $PROFILEtárolt profilt. A legegyszerűbb módszer a PowerShellben való futtatás notepad $PROFILE . További információért lásd: A profil létrehozása és Profilok és végrehajtási szabályzat.

  2. Adja hozzá a következő kódot a PowerShell-profilhoz:

    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. A menüben elérhető összes lehetőség megjelenítéséhez adja hozzá Set-PSReadlineKeyHandler -Key Tab -Function MenuComplete a PowerShell-profiljához.

Lásd még