Tworzenie i wdrażanie aplikacji maszyn wirtualnych

Aplikacje maszyn wirtualnych to typ zasobu w galerii obliczeń platformy Azure (wcześniej znanej jako galeria obrazów udostępnionych), który upraszcza zarządzanie, udostępnianie i globalną dystrybucję aplikacji dla maszyn wirtualnych.

Wymagania wstępne

Przed rozpoczęciem upewnij się, że masz następujące elementy:

W tym artykule założono, że masz już galerię obliczeń platformy Azure. Jeśli nie masz jeszcze galerii, najpierw utwórz jedną z nich. Aby dowiedzieć się więcej, zobacz Tworzenie galerii do przechowywania i udostępniania zasobów.

Aplikacja powinna zostać przekazana do kontenera na koncie usługi Azure Storage. Aplikację można przechowywać w bloku lub stronicowym obiekcie blob. Jeśli zdecydujesz się użyć stronicowego obiektu blob, przed ich przekazaniem należy wyrównać bajty. Oto przykład, który będzie wyrównywać plik w bajtach:

$inputFile = <the file you want to pad>

$fileInfo = Get-Item -Path $inputFile

$remainder = $fileInfo.Length % 512

if ($remainder -ne 0){

    $difference = 512 - $remainder

    $bytesToPad = [System.Byte[]]::CreateInstance([System.Byte], $difference)

    Add-Content -Path $inputFile -Value $bytesToPad -Encoding Byte
    }

Upewnij się, że konto magazynu ma dostęp na poziomie publicznym lub użyj identyfikatora URI sygnatury dostępu współdzielonego z uprawnieniami do odczytu, ponieważ inne poziomy ograniczeń kończą się niepowodzeniem. Jeśli jeszcze go nie masz, możesz użyć Eksplorator usługi Storage, aby szybko utworzyć identyfikator URI sygnatury dostępu współdzielonego.

Jeśli używasz programu PowerShell, musisz użyć wersji 3.11.0 modułu Az.Storage.

Aby dowiedzieć się więcej o mechanizmie instalacji, zobacz interpreter poleceń.

Tworzenie aplikacji maszyny wirtualnej

Wybierz poniżej opcję tworzenia definicji i wersji aplikacji maszyny wirtualnej:

Portal

1. Przejdź do witryny Azure Portal, a następnie wyszukaj i wybierz pozycję Galeria obliczeń platformy Azure.
2. Wybierz galerię, której chcesz użyć z listy.
3. Na stronie galerii wybierz pozycję Dodaj w górnej części strony, a następnie z listy rozwijanej wybierz pozycję Definicja aplikacji maszyny wirtualnej. Zostanie otwarta strona Tworzenie definicji aplikacji maszyny wirtualnej.
4. Na karcie Podstawy wprowadź nazwę aplikacji i wybierz, czy aplikacja jest dla maszyn wirtualnych z systemem Linux, czy Windows.
5. Wybierz kartę Opcje publikowania, jeśli chcesz określić dowolne z następujących opcjonalnych ustawień definicji aplikacji maszyny wirtualnej:
   • Opis definicji aplikacji maszyny wirtualnej.
   • Data zakończenia życia
   • Łączenie z eula
   • Identyfikator URI oświadczenia o ochronie prywatności
   • Identyfikator URI informacji o wersji
6. Po zakończeniu wybierz pozycję Przejrzyj i utwórz.
7. Po zakończeniu walidacji wybierz pozycję Utwórz , aby wdrożyć definicję.
8. Po zakończeniu wdrażania wybierz pozycję Przejdź do zasobu.
9. Na stronie aplikacji wybierz pozycję Utwórz wersję aplikacji maszyny wirtualnej. Zostanie otwarta strona Tworzenie wersji aplikacji maszyny wirtualnej.
10. Wprowadź numer wersji, taki jak 1.0.0.
11. Wybierz region, w którym został przekazany pakiet aplikacji.
12. W obszarze Źródłowy pakiet aplikacji wybierz pozycję Przeglądaj. Wybierz konto magazynu, a następnie kontener, w którym znajduje się pakiet. Wybierz pakiet z listy, a następnie wybierz pozycję Wybierz po zakończeniu. Alternatywnie możesz wkleić identyfikator URI sygnatury dostępu współdzielonego w tym polu, jeśli jest to preferowane.
13. Wpisz skrypt Instalacji. Możesz również podać skrypt Uninstall i Update script (Odinstalowywanie skryptu) i Update script (Aktualizuj skrypt). Aby uzyskać informacje na temat tworzenia skryptów, zobacz Omówienie.
14. Jeśli masz domyślny plik konfiguracji przekazany do konta magazynu, możesz wybrać go w obszarze Konfiguracja domyślna.
15. Wybierz pozycję Wyklucz z najnowszej wersji, jeśli ta wersja nie ma być wyświetlana jako najnowsza wersja podczas tworzenia maszyny wirtualnej.
16. W obszarze Data zakończenia życia wybierz datę w przyszłości, aby śledzić, kiedy ta wersja ma zostać wycofana. Nie jest on usuwany ani usuwany automatycznie, tylko w przypadku własnego śledzenia.
17. Aby replikować tę wersję do innych regionów, wybierz kartę Replikacja i dodaj więcej regionów i wprowadź zmiany liczby replik na region. Oryginalny region, w którym utworzono wersję, musi znajdować się na liście i nie można go usunąć.
18. Po zakończeniu wprowadzania zmian wybierz pozycję Przejrzyj i utwórz w dolnej części strony.
19. Gdy walidacja jest wyświetlana jako przekazana, wybierz pozycję Utwórz , aby wdrożyć wersję aplikacji maszyny wirtualnej.

Teraz możesz utworzyć maszynę wirtualną i wdrożyć w niej aplikację maszyny wirtualnej przy użyciu portalu. Wystarczy utworzyć maszynę wirtualną jak zwykle, a następnie na karcie Zaawansowane wybierz pozycję Wybierz aplikację maszyny wirtualnej do zainstalowania.

Wybierz aplikację maszyny wirtualnej z listy, a następnie wybierz pozycję Zapisz w dolnej części strony.

Jeśli masz więcej niż jedną aplikację maszyny wirtualnej do zainstalowania, możesz ustawić kolejność instalacji dla każdej aplikacji maszyny wirtualnej z powrotem na karcie Zaawansowane.

Aplikację maszyny wirtualnej można również wdrożyć na aktualnie uruchomionych maszynach wirtualnych. Wybierz opcję Rozszerzenia i aplikacje w obszarze Ustawienia w menu po lewej stronie podczas wyświetlania szczegółów maszyny wirtualnej w portalu.

Wybierz pozycję Aplikacje maszyn wirtualnych , a następnie wybierz pozycję Dodaj aplikację , aby dodać aplikację maszyny wirtualnej.

Wybierz aplikację maszyny wirtualnej z listy, a następnie wybierz pozycję Zapisz w dolnej części strony.

Aby wyświetlić stan aplikacji maszyny wirtualnej, przejdź do karty Rozszerzenia i aplikacje/ustawienia i sprawdź stan rozszerzenia vmAppExtension:

Aby wyświetlić stan aplikacji maszyny wirtualnej dla usługi VMSS, przejdź do strony VMSS, Instances, select one of them, a następnie przejdź do vmAppExtension:

Interfejs wiersza polecenia

Aplikacje maszyn wirtualnych wymagają interfejsu wiersza polecenia platformy Azure w wersji 2.30.0 lub nowszej.

Utwórz definicję aplikacji maszyny wirtualnej przy użyciu polecenia az sig gallery-application create. W tym przykładzie tworzysz definicję aplikacji maszyny wirtualnej o nazwie myApp dla maszyn wirtualnych z systemem Linux.

az sig gallery-application create \
    --application-name myApp \
    --gallery-name myGallery \
    --resource-group myResourceGroup \
    --os-type Linux \
    --location "East US"

Utwórz wersję aplikacji maszyny wirtualnej przy użyciu polecenia az sig gallery-application version create. Dozwolone znaki dla wersji to liczby i kropki. Liczby muszą należeć do zakresu 32-bitowej liczby całkowitej. Format: MajorVersion.Wersja pomocnicza.Stosowanie poprawek.

Zastąp wartości parametrów własnymi.

az sig gallery-application version create \
   --version-name 1.0.0 \
   --application-name myApp \
   --gallery-name myGallery \
   --location "East US" \
   --resource-group myResourceGroup \
   --package-file-link "https://<storage account name>.blob.core.windows.net/<container name>/<filename>" \
   --install-command "mv myApp .\myApp\myApp" \
   --remove-command "rm .\myApp\myApp" \
   --update-command  "mv myApp .\myApp\myApp" \
   --default-configuration-file-link "https://<storage account name>.blob.core.windows.net/<container name>/<filename>"\

Ustaw aplikację maszyny wirtualnej na istniejącą maszynę wirtualną przy użyciu polecenia az vm application set i zastąp wartości parametrów własnymi.

az vm application set \
	--resource-group myResourceGroup \
	--name myVM \
  	--app-version-ids /subscriptions/{subID}/resourceGroups/MyResourceGroup/providers/Microsoft.Compute/galleries/myGallery/applications/myApp/versions/1.0.0 \
  	--treat-deployment-as-failure true

Aby ustawić wiele aplikacji na maszynie wirtualnej:

az vm application set \
	--resource-group myResourceGroup \
	--name myVM \
	--app-version-ids /subscriptions/{subId}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/galleries/myGallery/applications/myApp/versions/1.0.0 /subscriptions/{subId}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/galleries/myGallery/applications/myApp2/versions/1.0.1 \
	--treat-deployment-as-failure true true

Aby dodać aplikację do zestawu skalowania maszyn wirtualnych, użyj polecenia az vmss application set:

az vmss application set \
	--resource-group myResourceGroup \
	--name myVmss \
	--app-version-ids /subscriptions/{subId}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/galleries/myGallery/applications/myApp/versions/1.0.0 \
	--treat-deployment-as-failure true

Aby dodać wiele aplikacji do zestawu skalowania maszyn wirtualnych:

az vmss application set \
	--resource-group myResourceGroup \
	--name myVmss
	--app-version-ids /subscriptions/{subId}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/galleries/myGallery/applications/myApp/versions/1.0.0 /subscriptions/{subId}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/galleries/myGallery/applications/myApp2/versions/1.0.0 \
	--treat-deployment-as-failure true

Aby sprawdzić stan wdrożenia maszyny wirtualnej aplikacji, użyj polecenia az vm get-instance-view:

az vm get-instance-view -g myResourceGroup -n myVM --query "instanceView.extensions[?name == 'VMAppExtension']"

Aby sprawdzić stan wdrożenia usługi VMSS aplikacji, użyj polecenia az vmss get-instance-view:

az vmss get-instance-view --ids (az vmss list-instances -g myResourceGroup -n myVmss --query "[*].id" -o tsv) --query "[*].extensions[?name == 'VMAppExtension']"

Uwaga

Powyższe polecenie stanu wdrożenia zestawu skalowania maszyn wirtualnych nie wyświetla identyfikatora wystąpienia z wynikiem. Aby wyświetlić identyfikator wystąpienia ze stanem rozszerzenia w każdym wystąpieniu, wymagane jest dodatkowe wykonywanie skryptów. Zapoznaj się z poniższym przykładem interfejsu wiersza polecenia usługi VMSS, który zawiera składnię programu PowerShell:

$ids = az vmss list-instances -g myResourceGroup -n myVmss --query "[*].{id: id, instanceId: instanceId}" | ConvertFrom-Json
$ids | Foreach-Object {
    $iid = $_.instanceId
    Write-Output "instanceId: $iid" 
    az vmss get-instance-view --ids $_.id --query "extensions[?name == 'VMAppExtension']" 
}

Program PowerShell

Utwórz definicję aplikacji maszyny wirtualnej przy użyciu polecenia New-AzGalleryApplication. W tym przykładzie utworzymy aplikację systemu Linux o nazwie myApp w galerii zasobów myGallery Azure Compute w grupie zasobów myGallery i podano krótki opis aplikacji maszyny wirtualnej do własnego użytku. Zastąp wartości zgodnie z potrzebami.

$galleryName = "myGallery"
$rgName = "myResourceGroup"
$applicationName = "myApp"
New-AzGalleryApplication `
  -ResourceGroupName $rgName `
  -GalleryName $galleryName `
  -Location "East US" `
  -Name $applicationName `
  -SupportedOSType Linux `
  -Description "Backend Linux application for finance."

Utwórz wersję aplikacji przy użyciu polecenia New-AzGalleryApplicationVersion. Dozwolone znaki dla wersji to liczby i kropki. Liczby muszą należeć do zakresu 32-bitowej liczby całkowitej. Format: MajorVersion.Wersja pomocnicza.Stosowanie poprawek.

W tym przykładzie tworzysz numer wersji 1.0.0. Zastąp wartości zmiennych zgodnie z potrzebami.

$galleryName = "myGallery"
$rgName = "myResourceGroup"
$applicationName = "myApp"
$version = "1.0.0"
New-AzGalleryApplicationVersion `
   -ResourceGroupName $rgName `
   -GalleryName $galleryName `
   -GalleryApplicationName $applicationName `
   -Name $version `
   -PackageFileLink "https://<storage account name>.blob.core.windows.net/<container name>/<filename>" `
   -DefaultConfigFileLink "https://<storage account name>.blob.core.windows.net/<container name>/<filename>" `
   -Location "East US" `
   -Install "mv myApp .\myApp\myApp" `
   -Remove "rm .\myApp\myApp" `

Aby dodać aplikację do istniejącej maszyny wirtualnej, pobierz wersję aplikacji i użyj jej, aby uzyskać identyfikator wersji aplikacji maszyny wirtualnej. Użyj identyfikatora, aby dodać aplikację do konfiguracji maszyny wirtualnej.

$galleryName = "myGallery"
$rgName = "myResourceGroup"
$applicationName = "myApp"
$version = "1.0.0"
$vmName = "myVM"
$vm = Get-AzVM -ResourceGroupName $rgname -Name $vmName
$appVersion = Get-AzGalleryApplicationVersion `
   -GalleryApplicationName $applicationName `
   -GalleryName $galleryName `
   -Name $version `
   -ResourceGroupName $rgName
$packageId = $appVersion.Id
$app = New-AzVmGalleryApplication -PackageReferenceId $packageId
Add-AzVmGalleryApplication -VM $vm -GalleryApplication $app -TreatFailureAsDeploymentFailure true
Update-AzVM -ResourceGroupName $rgName -VM $vm

Aby dodać aplikację do zestawu skalowania maszyn wirtualnych:

$vmss = Get-AzVmss -ResourceGroupName $rgname -Name $vmssName
$appVersion = Get-AzGalleryApplicationVersion `
   -GalleryApplicationName $applicationName `
   -GalleryName $galleryName `
   -Name $version `
   -ResourceGroupName $rgName
$packageId = $appVersion.Id
$app = New-AzVmssGalleryApplication -PackageReferenceId $packageId
Add-AzVmssGalleryApplication -VirtualMachineScaleSetVM $vmss.VirtualMachineProfile -GalleryApplication $app
Update-AzVmss -ResourceGroupName $rgName -VirtualMachineScaleSet $vmss -VMScaleSetName $vmssName

Sprawdź, czy aplikacja zakończyła się pomyślnie:

$rgName = "myResourceGroup"
$vmName = "myVM"
$result = Get-AzVM -ResourceGroupName $rgName -VMName $vmName -Status
$result.Extensions | Where-Object {$_.Name -eq "VMAppExtension"} | ConvertTo-Json

Aby sprawdzić usługę VMSS:

$rgName = "myResourceGroup"
$vmssName = "myVMss"
$result = Get-AzVmssVM -ResourceGroupName $rgName -VMScaleSetName $vmssName -InstanceView
$resultSummary  = New-Object System.Collections.ArrayList
$result | ForEach-Object {
    $res = @{ instanceId = $_.InstanceId; vmappStatus = $_.InstanceView.Extensions | Where-Object {$_.Name -eq "VMAppExtension"}}
    $resultSummary.Add($res) | Out-Null
}
$resultSummary | ConvertTo-Json -Depth 5

REST

Utwórz definicję aplikacji.

PUT
/subscriptions/\<**subscriptionId**\>/resourceGroups/\<**resourceGroupName**\>/providers/Microsoft.Compute/galleries/\<**galleryName**\>/applications/\<**applicationName**\>?api-version=2019-03-01

{
    "location": "West US",
    "name": "myApp",
    "properties": {
        "supportedOSType": "Windows | Linux",
        "endOfLifeDate": "2020-01-01"
    }
}

Nazwa pola	opis	Ograniczenia
name	Unikatowa nazwa aplikacji maszyny wirtualnej w galerii	Maksymalna długość 117 znaków. Dozwolone znaki to wielkie lub małe litery, cyfry, łącznik(-), kropka (.), podkreślenie (_). Nazwy nie mogą kończyć się kropką(.).
supportedOSType	Niezależnie od tego, czy jest to aplikacja systemu Windows, czy Linux	"Windows" lub "Linux"
endOfLifeDate	Data przyszłego zakończenia życia aplikacji. Należy pamiętać, że dotyczy to tylko odwołania i nie jest wymuszane.	Prawidłowa data przyszłej

Utwórz wersję aplikacji maszyny wirtualnej.

PUT
/subscriptions/\<**subscriptionId**\>/resourceGroups/\<**resourceGroupName**\>/providers/Microsoft.Compute/galleries/\<**galleryName**\>/applications/\<**applicationName**\>/versions/\<**versionName**\>?api-version=2019-03-01

{
  "location": "$location",
  "properties": {
    "publishingProfile": {
      "source": {
        "mediaLink": "$mediaLink",
        "defaultConfigurationLink": "$configLink"
      },
      "manageActions": {
        "install": "echo installed",
        "remove": "echo removed",
        "update": "echo update"
      },
      "targetRegions": [
        {
          "name": "$location1",
          "regionalReplicaCount": 1 
        },
        { "name": "$location1" }
      ]
    },
    "endofLifeDate": "datetime",
    "excludeFromLatest": "true | false"
  }
}

Nazwa pola	opis	Ograniczenia
lokalizacja	Lokalizacja źródłowa wersji aplikacji maszyny wirtualnej	Prawidłowy region świadczenia usługi Azure
mediaLink	Adres URL zawierający pakiet wersji aplikacji	Prawidłowy i istniejący adres URL magazynu
defaultConfigurationLink	Opcjonalny. Adres URL zawierający konfigurację domyślną, która może zostać zastąpiona w czasie wdrażania.	Prawidłowy i istniejący adres URL magazynu
Zainstaluj	Polecenie instalacji aplikacji	Prawidłowe polecenie dla danego systemu operacyjnego
Usuń	Polecenie umożliwiające usunięcie aplikacji	Prawidłowe polecenie dla danego systemu operacyjnego
Zaktualizuj	Opcjonalny. Polecenie aktualizacji aplikacji. Jeśli nie zostanie określona, a aktualizacja jest wymagana, stara wersja zostanie usunięta i zainstalowana nowa.	Prawidłowe polecenie dla danego systemu operacyjnego
targetRegions/name	Nazwa regionu, do którego ma być replikowana	Weryfikowanie regionu świadczenia usługi Azure
targetRegions/regionalReplicaCount	Opcjonalny. Liczba replik w regionie do utworzenia. Wartość domyślna to 1.	Liczba całkowita z zakresu od 1 do 3 włącznie
endOfLifeDate	Data przyszłego zakończenia życia wersji aplikacji. Należy pamiętać, że dotyczy to tylko dokumentacji klienta i nie jest wymuszana.	Prawidłowa data przyszłej
excludeFromLatest	Jeśli zostanie określona, ta wersja nie zostanie uznana za najnowszą.	Prawda czy fałsz

Aby dodać wersję aplikacji maszyny wirtualnej do maszyny wirtualnej, wykonaj operację PUT na maszynie wirtualnej.

PUT
/subscriptions/\<**subscriptionId**\>/resourceGroups/\<**resourceGroupName**\>/providers/Microsoft.Compute/virtualMachines/\<**VMName**\>?api-version=2019-03-01

{
  "properties": {
    "applicationProfile": {
      "galleryApplications": [
        {
          "order": 1,
          "packageReferenceId": "/subscriptions/{subscriptionId}/resourceGroups/<resource group>/providers/Microsoft.Compute/galleries/{gallery name}/applications/{application name}/versions/{version}",
          "configurationReference": "{path to configuration storage blob}",
          "treatFailureAsDeploymentFailure": false
        }
      ]
    }
  },
  "name": "{vm name}",
  "id": "/subscriptions/{subscriptionId}/resourceGroups/{resource group}/providers/Microsoft.Compute/virtualMachines/{vm name}",
  "location": "{vm location}"
}

Aby zastosować aplikację maszyny wirtualnej do ujednoliconego zestawu skalowania:

PUT
/subscriptions/\<**subscriptionId**\>/resourceGroups/\<**resourceGroupName**\>/providers/Microsoft.Compute/
virtualMachineScaleSets/\<**VMSSName**\>?api-version=2019-03-01

{
  "properties": {
    "virtualMachineProfile": {
      "applicationProfile": {
        "galleryApplications": [
          {
            "order": 1,
            "packageReferenceId": "/subscriptions/{subscriptionId}/resourceGroups/<resource group>/providers/Microsoft.Compute/galleries/{gallery name}/applications/{application name}/versions/{version}",
            "configurationReference": "{path to configuration storage blob}",
            "treatFailureAsDeploymentFailure": false
          }
        ]
      }
    }
  },
  "name": "{vm name}",
  "id": "/subscriptions/{subscriptionId}/resourceGroups/{resource group}/providers/Microsoft.Compute/virtualMachines/{vm name}",
  "location": "{vm location}"
}

Nazwa pola	opis	Ograniczenia
order	Opcjonalny. Kolejność wdrażania aplikacji. Zobacz poniżej.	Weryfikowanie liczby całkowitej
packageReferenceId	Odwołanie do wersji aplikacji galerii	Prawidłowa dokumentacja wersji aplikacji
configurationReference	Opcjonalny. Pełny adres URL obiektu blob magazynu zawierającego konfigurację dla tego wdrożenia. Spowoduje to zastąpienie dowolnej wartości podanej dla parametru defaultConfiguration wcześniej.	Prawidłowa dokumentacja obiektu blob magazynu
treatFailureAsDeploymentFailure	Opcjonalny. Stan aprowizacji aplikacji maszyny wirtualnej. W przypadku ustawienia wartości false stan aprowizacji zawsze będzie wyświetlany jako "powodzenie", niezależnie od niepowodzenia wdrażania aplikacji.	True lub False

Pole zamówienia może służyć do określania zależności między aplikacjami. Reguły dotyczące kolejności są następujące:

Sprawa	Znaczenie instalacji	Znaczenie błędu
Nie określono zamówienia	Aplikacje nieurządzane są instalowane po uporządkowanych aplikacjach. Nie ma gwarancji kolejności instalacji wśród nieurządzanych aplikacji.	Błędy instalacji innych aplikacji, jeśli są uporządkowane lub nieurządzone, nie wpływają na instalację nieurządkowanych aplikacji.
Zduplikowane wartości kolejności	Aplikacja jest instalowana w dowolnej kolejności w porównaniu z innymi aplikacjami z tą samą kolejnością. Wszystkie aplikacje tego samego zamówienia zostaną zainstalowane po tych z niższymi zamówieniami i przed tymi z wyższymi zamówieniami.	Jeśli instalacja poprzedniej aplikacji o niższej kolejności nie powiodła się, nie ma aplikacji z tą kolejnością instalacji. Jeśli instalacja jakiejkolwiek aplikacji z tą kolejnością nie powiedzie się, nie ma aplikacji z instalacją wyższego zamówienia.
Zwiększanie zamówień	Aplikacja zostanie zainstalowana po tych z niższymi zamówieniami i przed tymi z wyższymi zamówieniami.	Jeśli instalacja poprzedniej aplikacji o niższej kolejności nie powiodła się, ta aplikacja nie zostanie zainstalowana. Jeśli instalacja tej aplikacji nie powiedzie się, żadna aplikacja nie ma zainstalowanej wyższej kolejności.

Odpowiedź zawiera pełny model maszyny wirtualnej. Poniżej przedstawiono odpowiednie części.

{
  "name": "{vm name}",
  "id": "{vm id}",
  "type": "Microsoft.Compute/virtualMachines",
  "location": "{vm location}",
  "properties": {
    "applicationProfile": {
      "galleryApplications": ""
    },
    "provisioningState": "Updating"
  },
  "resources": [
    {
      "name": "VMAppExtension",
      "id": "{extension id}",
      "type": "Microsoft.Compute/virtualMachines/extensions",
      "location": "centraluseuap",
      "properties": "@{autoUpgradeMinorVersion=True; forceUpdateTag=7c4223fc-f4ea-4179-ada8-c8a85a1399f5; provisioningState=Creating; publisher=Microsoft.CPlat.Core; type=VMApplicationManagerLinux; typeHandlerVersion=1.0; settings=}"
    }
  ]
}

Jeśli aplikacje maszyn wirtualnych nie zostały jeszcze zainstalowane na maszynie wirtualnej, wartość będzie pusta.

Aby uzyskać wynik widoku wystąpienia maszyny wirtualnej:

GET
/subscriptions/\<**subscriptionId**\>/resourceGroups/\<**resourceGroupName**\>/providers/Microsoft.Compute/virtualMachines/\<**VMName**\>/instanceView?api-version=2019-03-01

Wynik wygląda następująco:

{
    ...
    "extensions"  [
    ...
        {
            "name":  "VMAppExtension",
            "type":  "Microsoft.CPlat.Core.VMApplicationManagerLinux",
            "typeHandlerVersion":  "1.0.9",
            "statuses":  [
                            {
                                "code":  "ProvisioningState/succeeded",
                                "level":  "Info",
                                "displayStatus":  "Provisioning succeeded",
                                "message":  "Enable succeeded: {\n \"CurrentState\": [\n  {\n   \"applicationName\": \"doNothingLinux\",\n   \"version\": \"1.0.0\",\n   \"result\": \"Install SUCCESS\"\n  },\n  {
        \n   \"applicationName\": \"badapplinux\",\n   \"version\": \"1.0.0\",\n   \"result\": \"Install FAILED Error executing command \u0027exit 1\u0027: command terminated with exit status=1\"\n  }\n ],\n \"ActionsPerformed\": []\n}
        "
                            }
                        ]
        }
    ...
    ]
}

Stan aplikacji maszyny wirtualnej znajduje się w komunikacie o stanie wyniku rozszerzenia aplikacji maszyny wirtualnej w widoku wystąpienia.

Aby uzyskać stan aplikacji zestawu skalowania maszyn wirtualnych:

GET
/subscriptions/\<**subscriptionId**\>/resourceGroups/\<**resourceGroupName**\>/providers/Microsoft.Compute/ virtualMachineScaleSets/\<**VMSSName**\>/virtualMachines/<**instanceId**>/instanceView?api-version=2019-03-01

Dane wyjściowe są podobne do przykładu maszyny wirtualnej wcześniej.

Następne kroki

Dowiedz się więcej o aplikacjach maszyn wirtualnych.