ความช่วยเหลือ Azure CLI และ PowerShell ด้วย GitHub Copilot

8 นาที

Tip

ดูแท็บ ข้อความและรูปภาพ สําหรับรายละเอียดเพิ่มเติม!

แม้จะมีการเพิ่มขึ้นของเครื่องมือ IaC แบบประกาศ เช่น Bicep แต่เครื่องมือบรรทัดคําสั่ง เช่น Azure CLI และ Azure PowerShell ยังคงจําเป็นสําหรับวิศวกรระบบคลาวด์ งานบางอย่างไม่พอดีกับเทมเพลต: การตรวจสอบก่อนการปรับใช้ การโยกย้ายข้อมูล รันบุ๊กการดําเนินงาน การแก้ไขปัญหาที่ไม่ได้วางแผนไว้ และระบบอัตโนมัติที่เกี่ยวข้องกับตรรกะหรือลูปแบบมีเงื่อนไข

สคริปต์ CommandLine (CLI) มักเป็นสิ่งแรกที่ทีมเอื้อมถึงเมื่อมีบางอย่างเกิดขึ้นอย่างรวดเร็ว ความเร็วที่คุณสามารถเขียนและเรียกใช้สคริปต์มีความสําคัญ ตรงที่ GitHub Copilot เพิ่มมูลค่าในทันที แทนที่จะค้นหาเอกสารประกอบสําหรับคําสั่งที่ถูกต้องและพารามิเตอร์ คุณจะอธิบายสิ่งที่คุณต้องการในภาษาธรรมดา และ Copilot จะสร้างสคริปต์

Azure CLI เทียบกับ Azure PowerShell

ช่วยให้เข้าใจว่าควรเข้าถึงเครื่องมือใดก่อนที่จะสร้างสคริปต์

Azure CLI (az) เป็นเครื่องมือบรรทัดคําสั่งข้ามแพลตฟอร์มที่ทํางานบน Windows, macOS และ Linux เอาต์พุตเป็น JSON โดยค่าเริ่มต้น ทําให้ง่ายต่อการไปป์ไปยังเครื่องมืออื่นๆ Azure CLI ใช้กันอย่างแพร่หลายในสคริปต์ bash ตัวแทน CI/CD ที่ใช้ Linux และโดยทีมที่มีพื้นฐาน Linux หรือ DevOps

Azure PowerShell (โมดูล Az) ใช้ภาษา PowerShell และทํางานบน Windows, macOS และ Linux ผ่าน PowerShell 7+ ผลลัพธ์เป็นวัตถุ .NET ที่มีโครงสร้าง ซึ่งทําให้มีประสิทธิภาพสําหรับตรรกะ การกรอง และการรวมเข้ากับบริการอื่นๆ ของ บริการของ Microsoft ที่ซับซ้อน PowerShell ดูเหมือนจะเป็นที่ต้องการของทีมที่ใช้ Windows และผู้ดูแลระบบ

เครื่องมือทั้งสองครอบคลุมการดําเนินการ Azure เดียวกัน การเลือกระหว่างพวกเขาส่วนใหญ่เป็นคําถามว่าทีมของคุณคุ้นเคยกับภาษาใดมากที่สุดและสภาพแวดล้อมที่สคริปต์ของคุณทํางาน GitHub Copilot จัดการทั้งสองอย่างได้อย่างคล่องแคล่วและสามารถแปลระหว่างกันได้

สร้างสคริปต์ Azure CLI ด้วย Copilot

เริ่มต้นง่ายๆ

สําหรับการสร้างทรัพยากรที่ตรงไปตรงมา Copilot รู้โครงสร้างคําสั่ง az และสามารถสร้างไวยากรณ์ที่ถูกต้องสําหรับการดําเนินการทั่วไป

ตัวอย่างข้อความแจ้งอาจมีลักษณะดังนี้:

Generate an Azure CLI command to create a resource group called "rg-webapp-prod" in the West Europe region, tagged with Environment=Production and Owner=platform-team.

โดยที่การตอบสนองของ GitHub Copilot อาจคล้ายกับ:

az group create \
  --name rg-webapp-prod \
  --location westeurope \
  --tags Environment=Production Owner=platform-team

สําหรับคําสั่งเดียว ไวยากรณ์จะตรงไปตรงมา ค่าที่แท้จริงจะปรากฏขึ้นเมื่อคุณขอให้ GitHub Copilot สร้างสคริปต์ที่สมบูรณ์ด้วยหลายขั้นตอน ตัวแปร และการจัดการข้อผิดพลาด

สร้างสคริปต์การจัดสรรแบบเต็ม

ในวิธีการขั้นสูงนี้ พร้อมท์ของคุณอาจมีรายละเอียดเพิ่มเติม เช่น ตัวอย่างที่นี่:

Generate an Azure CLI bash script that provisions the following resources:
- Resource group: rg-iaclab in East US
- VNet: vnet-iaclab with address space 10.0.0.0/16
- Subnet: snet-app at 10.0.1.0/24
- NSG: nsg-app with a rule denying all inbound internet traffic
  except HTTPS (port 443)
- Associate the NSG with snet-app

Requirements:
- Use variables at the top for all configurable values
- Check if the resource group already exists before creating it
- Print a status message after each successful resource creation
- Exit immediately if any command fails (set -e)
- Tag all resources with Environment=Training and Owner=lab-user

Copilot สร้างสคริปต์ที่มีบล็อกตัวแปรที่สะอาด การตรวจสอบความสมบูรณ์ และข้อความสถานะ เทคนิคการเตือนที่สําคัญที่นี่คือ:

ตัวแปรที่ด้านบน: ป้องกันไม่ให้ค่าฮาร์ดโค้ดกระจัดกระจายไปทั่วสคริปต์
การตรวจสอบการมีอยู่ก่อนสร้าง: ทําให้สคริปต์ idempotent (ปลอดภัยในการเรียกใช้ซ้ํา)
ออกจากความล้มเหลว (set -e): ป้องกันไม่ให้ความล้มเหลวแบบเงียบแพร่กระจาย

เพิ่มอุดมการณ์

Idempotency หมายถึงสคริปต์ให้ผลลัพธ์เดียวกัน ไม่ว่าจะเรียกใช้ครั้งเดียวหรือ 10 ครั้ง ซึ่งเป็นสิ่งสําคัญสําหรับสคริปต์ระบบอัตโนมัติที่อาจทํางานตามกําหนดการหรือเป็นส่วนหนึ่งของไปป์ไลน์ CI/CD

ต่อไปนี้คือตัวอย่างของการใช้ข้อความแจ้งเพื่อเพิ่ม idempotency ให้กับการสร้างสคริปต์ของคุณ:

Refactor this script so that each resource creation command first checks whether the resource already exists. If it exists, print "already exists — skipping" and continue. If it does not exist, create it.
Use az [resource] show with a 2>/dev/null check to test for existence.

Copilot ตัดแต่ละคําสั่ง az ... create ในรูปแบบการตรวจสอบการมีอยู่:

if ! az network vnet show --name "$VNET_NAME" --resource-group "$RG_NAME" \
     --query id -o tsv 2>/dev/null; then
  echo "Creating VNet: $VNET_NAME..."
  az network vnet create \
    --name "$VNET_NAME" \
    --resource-group "$RG_NAME" \
    --address-prefix "$VNET_PREFIX"
  echo "VNet created successfully."
else
  echo "VNet $VNET_NAME already exists — skipping."
fi

เพิ่มการตรวจสอบพารามิเตอร์

กรณีการใช้งานที่มีประโยชน์อีกกรณีหนึ่งคือการใช้การตรวจสอบความถูกต้องของพารามิเตอร์ ซึ่งเป็นส่วนหนึ่งของพรอมต์ของคุณ ดูตัวอย่างที่นี่:

Add a validation block at the top of the script that:
- Checks that the az CLI is installed and the user is logged in
- Verifies the target subscription is set correctly
- Accepts RESOURCE_GROUP, LOCATION, and OWNER as command-line arguments
  and exits with a usage message if they are not provided

รูปแบบนี้ทําให้สคริปต์เหมาะสําหรับใช้ในไปป์ไลน์ระบบอัตโนมัติที่อินพุตมาจากตัวแปรสภาพแวดล้อมหรือพารามิเตอร์ CI/CD แทนที่จะเป็นค่าฮาร์ดโค้ด

สร้างสคริปต์ Azure PowerShell ด้วย GitHub Copilot

วิธีการภาษาธรรมชาติเดียวกันนี้ใช้ได้กับ PowerShell (Azure) Copilot เข้าใจ cmdlet โมดูล Az และสร้าง PowerShell สํานวนแทนการแปลไวยากรณ์ CLI แบบคําต่อคํา

การรวมภาษาสคริปต์ที่จําเป็นไว้ในพร้อมท์ คุณจะจํากัดขอบเขต GitHub Copilot ให้แคบลง:

Generate an Azure PowerShell script that:
- Connects to Azure using a service principal (client ID, client secret,
  tenant ID passed as parameters)
- Creates a resource group "rg-iaclab" in East US if it does not already exist
- Creates a Storage Account with Standard_LRS SKU, HTTPS-only access,
  and blob soft delete enabled (30 days)
- Outputs the storage account's primary connection string at the end
Use proper error handling with try/catch blocks.

GitHub Copilot ตอบสนองด้วยไวยากรณ์ PowerShell ที่ชัดเจน โดยทําความเข้าใจทรัพยากรและพารามิเตอร์ของ Azure:

param(
    [Parameter(Mandatory=$true)][string]$TenantId,
    [Parameter(Mandatory=$true)][string]$ClientId,
    [Parameter(Mandatory=$true)][string]$ClientSecret,
    [string]$Location = "eastus",
    [string]$ResourceGroupName = "rg-iaclab",
    [string]$StorageAccountName = "stiaclab$(Get-Random -Maximum 9999)"
)

# Connect using service principal
$SecureSecret = ConvertTo-SecureString $ClientSecret -AsPlainText -Force
$Credential = New-Object System.Management.Automation.PSCredential($ClientId, $SecureSecret)

try {
    Connect-AzAccount -ServicePrincipal -Credential $Credential -Tenant $TenantId
    Write-Host "Connected to Azure successfully." -ForegroundColor Green
} catch {
    Write-Error "Failed to connect to Azure: $_"
    exit 1
}

# Create resource group if it does not exist
$RG = Get-AzResourceGroup -Name $ResourceGroupName -ErrorAction SilentlyContinue
if (-not $RG) {
    Write-Host "Creating resource group: $ResourceGroupName..."
    New-AzResourceGroup -Name $ResourceGroupName -Location $Location `
        -Tag @{ Environment = "Training"; Owner = "lab-user" }
}

โปรดสังเกตว่า Copilot สร้างรูปแบบสํานวน PowerShell ตามธรรมชาติ: บล็อก param(), try/catch, -ErrorAction SilentlyContinue และไวยากรณ์การขยาย $(...) ไม่ได้พยายามจําลองรูปแบบ bash ใน PowerShell

แปลระหว่าง CLI และ PowerShell

หนึ่งในการใช้งาน GitHub Copilot ที่ใช้งานได้จริงที่สุดสําหรับงานโครงสร้างพื้นฐานคือการแปลงสคริปต์ระหว่างเครื่องมือ สถานการณ์ทั่วไปคือ:

สคริปต์ที่เขียนโดยทีมที่เน้น Linux เป็นศูนย์กลางและจําเป็นต้องทํางานบน Windows
ตัวอย่างเอกสารประกอบอยู่ใน CLI แต่ทีมของคุณใช้ PowerShell
คุณต้องการสร้างมาตรฐานระบบอัตโนมัติทั้งหมดให้เป็นภาษาเดียว

ตัวอย่างของพรอมต์การเปลี่ยนแปลงดังกล่าวอาจคล้ายกับตัวอย่างนี้:

Translate the following Azure CLI bash script to Azure PowerShell.
Use Az module cmdlets throughout. Preserve:
- The same variable/parameter names where possible
- All error handling logic
- The existence check pattern before each resource creation
- Tag application on all resources
Do not add features that are not in the original script.

[paste your CLI script here]

คําแนะนํา Do not add features that are not in the original เป็นสิ่งสําคัญ หากไม่มี บางครั้ง Copilot จะเพิ่มการบันทึก การวัดและส่งข้อมูลทางไกล หรือฟังก์ชันพิเศษที่ไม่ได้ร้องขอ ทําให้ยากต่อการเปรียบเทียบสคริปต์ทั้งสองและตรวจสอบความเท่าเทียมกัน

คีย์ CLI-to-PowerShell เทียบเท่า

การทําความเข้าใจการแมปช่วยให้คุณตรวจสอบการแปลของ Copilot:

Azure CLI	Azure PowerShell
`az group create`	`New-AzResourceGroup`
`az group show`	`Get-AzResourceGroup`
`az network vnet create`	`New-AzVirtualNetwork`
`az network nsg create`	`New-AzNetworkSecurityGroup`
`az vm create`	`New-AzVM`
`az storage account create`	`New-AzStorageAccount`
`az keyvault create`	`New-AzKeyVault`
`--query` + `--output tsv`	`Select-Object` + `.PropertyName`
`$?` (ตรวจสอบรหัสออก)	`$?` หรือ `try/catch`

รูปแบบการปฏิบัติสําหรับงาน Copilot-Assisted CLI

สร้างคําสั่งสําหรับทรัพยากรที่ไม่คุ้นเคย

แม้แต่วิศวกร Azure ที่มีประสบการณ์ก็ยังพบกับประเภททรัพยากร Azure ที่พวกเขาเคยทํางานด้วยมาก่อน Copilot ลบการค้นหาเอกสารประกอบ:

การรวมการอ้างอิงที่ชัดเจนไปยังชนิดทรัพยากร Azure ในพรอมต์ของคุณก็เพียงพอแล้วสําหรับ Copilot ในการสร้างคําสั่งที่ถูกต้อง:

Generate an Azure CLI command to create an Azure Container Registry with
Premium SKU, geo-replication to West Europe, admin account disabled,
and a system-assigned managed identity. Output the login server at the end.

Copilot สร้างคําสั่ง az acr create ที่ถูกต้องด้วยชื่อแฟล็กที่ถูกต้อง รวมถึงค่าสถานะที่ลืมง่าย เช่น --sku, --admin-enabled falseและ--identity [system]

สร้างสคริปต์การล้างข้อมูล

สคริปต์การล้างข้อมูลมีความสําคัญในสภาพแวดล้อมการฝึกอบรมและการพัฒนา Copilot สร้างได้อย่างรวดเร็ว ตัวอย่างของข้อความแจ้งดังกล่าวอาจมีลักษณะดังนี้:

Generate an Azure CLI script that:
- Lists all resource groups with the tag Environment=Training
- Prints each group name and asks for confirmation before deleting
- Deletes confirmed groups with --no-wait for speed
- Reports how many groups were deleted at the end

สร้างสคริปต์แบบข้ามการสมัครใช้บริการ

สภาพแวดล้อมขององค์กรมักอาศัยการสมัครใช้งาน Azure หลายรายการ ด้วย GitHub Copilot ความซับซ้อนที่เพิ่มขึ้นนี้ง่ายต่อการจัดการ รวมข้อมูลจําเพาะนั้นเป็นส่วนหนึ่งของพร้อมท์ของคุณ ดังที่แสดงไว้ที่นี่:

Generate an Azure CLI script that iterates over all subscriptions in my tenant,
checks each one for storage accounts that have public blob access enabled,
and outputs a CSV report with: SubscriptionName, ResourceGroup, StorageAccountName, Location.

Copilot สร้างโครงสร้างลูปโดยใช้ az account list และ az account set อย่างถูกต้อง โดยจัดการสวิตช์บริบทการสมัครใช้งานที่ทําให้วิศวกรหลายคนสะดุดเขียนตั้งแต่เริ่มต้น

ประเด็นสําคัญ

Azure CLI และ PowerShell เป็นสิ่งจําเป็นสําหรับการดําเนินงานและระบบอัตโนมัติแบบมีเงื่อนไขที่ไม่เหมาะกับเทมเพลตการประกาศ
พรอมต์ CLI ที่มีประสิทธิภาพ ได้แก่ บล็อกตัวแปร การตรวจสอบการมีอยู่ การจัดการข้อผิดพลาด และข้อกําหนดของแท็ก
Copilot สร้างเอาต์พุตสํานวนทั้งใน CLI และ PowerShell ไม่ใช่การแปลเชิงกลของสิ่งหนึ่งไปยังอีกอย่างหนึ่ง
ใช้รูปแบบการแปล ("แปลสคริปต์ CLI นี้เป็น PowerShell รักษาตรรกะทั้งหมด อย่าเพิ่มคุณลักษณะ") เพื่อการแปลงข้ามเครื่องมือที่เชื่อถือได้
ใช้ CLI สําหรับงานปฏิบัติการและงานตามเงื่อนไข ใช้ Bicep เพื่อจัดการสถานะโครงสร้างพื้นฐานที่มีอายุการใช้งานยาวนาน

คำติชม

หน้านี้มีประโยชน์หรือไม่