Zarządzanie zasobami usługi Application Insights przy użyciu programu PowerShell

Artykuł
11/05/2024

Uwaga

Do interakcji z platformą Azure zalecamy używanie modułu Azure Az w programie PowerShell. Zobacz Instalowanie programu Azure PowerShell, aby rozpocząć. Aby dowiedzieć się, jak przeprowadzić migrację do modułu Az PowerShell, zobacz Migracja programu Azure PowerShell z modułu AzureRM do modułu Az.

W tym artykule pokazano, jak zautomatyzować automatyczne tworzenie i aktualizowanie zasobów usługi Application Insights przy użyciu usługi Azure Resource Manager. Możesz na przykład to zrobić w ramach procesu kompilacji. Oprócz podstawowego zasobu usługi Application Insights można tworzyć testy internetowe dostępności, konfigurować alerty, ustawiać schemat cen i tworzyć inne zasoby platformy Azure.

Kluczem do tworzenia tych zasobów jest szablony JSON dla usługi Resource Manager. Podstawowa procedura to:

Pobierz definicje JSON istniejących zasobów.
Parametryzowanie niektórych wartości, takich jak nazwy.
Uruchom szablon za każdym razem, gdy chcesz utworzyć nowy zasób.

Możesz spakować kilka zasobów razem, aby utworzyć je wszystkie w jednym miejscu. Można na przykład utworzyć monitor aplikacji z testami dostępności, alertami i magazynem na potrzeby eksportu ciągłego. Istnieje kilka subtelności do niektórych parametryzacji, które wyjaśniamy tutaj.

Jednorazowa konfiguracja

Jeśli wcześniej nie używasz programu PowerShell z subskrypcją platformy Azure, zainstaluj moduł Azure PowerShell na maszynie, na której chcesz uruchomić skrypty:

Zainstaluj Instalator platformy Microsoft Web (wersja 5 lub nowsza).
Użyj go do zainstalowania programu Azure PowerShell.

Oprócz korzystania z szablonów usługi Azure Resource Manager (szablonów usługi ARM) dostępny jest bogaty zestaw poleceń cmdlet programu PowerShell usługi Application Insights. Te polecenia cmdlet ułatwiają programowe konfigurowanie zasobów usługi Application Insights. Możesz użyć funkcji włączonych przez polecenia cmdlet, aby:

Tworzenie i usuwanie zasobów usługi Application Insights.
Pobieranie list zasobów usługi Application Insights i ich właściwości.
Tworzenie eksportu ciągłego i zarządzanie nim.
Tworzenie kluczy aplikacji i zarządzanie nimi.
Ustaw dzienny limit.
Ustaw plan cenowy.

Tworzenie zasobów usługi Application Insights przy użyciu polecenia cmdlet programu PowerShell

Poniżej przedstawiono sposób tworzenia nowego zasobu usługi Application Insights w centrum danych Azure Wschodnie stany USA przy użyciu polecenia cmdlet New-AzApplicationInsights :

New-AzApplicationInsights -ResourceGroupName <resource group> -Name <resource name> -location eastus

Tworzenie zasobów usługi Application Insights przy użyciu szablonu usługi ARM

Poniżej przedstawiono sposób tworzenia nowego zasobu usługi Application Insights przy użyciu szablonu usługi ARM.

Tworzenie szablonu usługi ARM

Utwórz nowy plik .json. Nazwijmy to template1.json w tym przykładzie. Skopiuj do niej tę zawartość:

    {
        "$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
        "contentVersion": "1.0.0.0",
        "parameters": {
            "appName": {
                "type": "string",
                "metadata": {
                    "description": "Enter the name of your Application Insights resource."
                }
            },
            "appType": {
                "type": "string",
                "defaultValue": "web",
                "allowedValues": [
                    "web",
                    "java",
                    "other"
                ],
                "metadata": {
                    "description": "Enter the type of the monitored application."
                }
            },
            "appLocation": {
                "type": "string",
                "defaultValue": "eastus",
                "metadata": {
                    "description": "Enter the location of your Application Insights resource."
                }
            },
            "retentionInDays": {
                "type": "int",
                "defaultValue": 90,
                "allowedValues": [
                    30,
                    60,
                    90,
                    120,
                    180,
                    270,
                    365,
                    550,
                    730
                ],
                "metadata": {
                    "description": "Data retention in days"
                }
            },
            "ImmediatePurgeDataOn30Days": {
                "type": "bool",
                "defaultValue": false,
                "metadata": {
                    "description": "If set to true when changing retention to 30 days, older data will be immediately deleted. Use this with extreme caution. This only applies when retention is being set to 30 days."
                }
            },
            "priceCode": {
                "type": "int",
                "defaultValue": 1,
                "allowedValues": [
                    1,
                    2
                ],
                "metadata": {
                    "description": "Pricing plan: 1 = Per GB (or legacy Basic plan), 2 = Per Node (legacy Enterprise plan)"
                }
            },
            "dailyQuota": {
                "type": "int",
                "defaultValue": 100,
                "minValue": 1,
                "metadata": {
                    "description": "Enter daily quota in GB."
                }
            },
            "dailyQuotaResetTime": {
                "type": "int",
                "defaultValue": 0,
                "metadata": {
                    "description": "Enter daily quota reset hour in UTC (0 to 23). Values outside the range will get a random reset hour."
                }
            },
            "warningThreshold": {
                "type": "int",
                "defaultValue": 90,
                "minValue": 1,
                "maxValue": 100,
                "metadata": {
                    "description": "Enter the % value of daily quota after which warning mail to be sent. "
                }
            }
        },
        "variables": {
            "priceArray": [
                "Basic",
                "Application Insights Enterprise"
            ],
            "pricePlan": "[take(variables('priceArray'),parameters('priceCode'))]",
            "billingplan": "[concat(parameters('appName'),'/', variables('pricePlan')[0])]"
        },
        "resources": [
            {
                "type": "microsoft.insights/components",
                "kind": "[parameters('appType')]",
                "name": "[parameters('appName')]",
                "apiVersion": "2014-04-01",
                "location": "[parameters('appLocation')]",
                "tags": {},
                "properties": {
                    "ApplicationId": "[parameters('appName')]",
                    "retentionInDays": "[parameters('retentionInDays')]",
                    "ImmediatePurgeDataOn30Days": "[parameters('ImmediatePurgeDataOn30Days')]"
                },
                "dependsOn": []
            },
            {
                "name": "[variables('billingplan')]",
                "type": "microsoft.insights/components/CurrentBillingFeatures",
                "location": "[parameters('appLocation')]",
                "apiVersion": "2015-05-01",
                "dependsOn": [
                    "[resourceId('microsoft.insights/components', parameters('appName'))]"
                ],
                "properties": {
                    "CurrentBillingFeatures": "[variables('pricePlan')]",
                    "DataVolumeCap": {
                        "Cap": "[parameters('dailyQuota')]",
                        "WarningThreshold": "[parameters('warningThreshold')]",
                        "ResetTime": "[parameters('dailyQuotaResetTime')]"
                    }
                }
            }
        ]
    }

Tworzenie nowego zasobu usługi Application Insights przy użyciu szablonu usługi ARM

W programie PowerShell zaloguj się do platformy Azure przy użyciu polecenia $Connect-AzAccount.
Ustaw kontekst na subskrypcję z wartością Set-AzContext "<subscription ID>".
Uruchom nowe wdrożenie, aby utworzyć nowy zasób usługi Application Insights:
```
    New-AzResourceGroupDeployment -ResourceGroupName Fabrikam `
           -TemplateFile .\template1.json `
           -appName myNewApp
```
- -ResourceGroupName to grupa, w której chcesz utworzyć nowe zasoby.
- -TemplateFile musi wystąpić przed parametrami niestandardowymi.
- -appName to nazwa zasobu do utworzenia.

Możesz dodać inne parametry. Ich opisy można znaleźć w sekcji parameters szablonu.

Pobieranie klucza instrumentacji

Po utworzeniu zasobu aplikacji chcesz użyć klucza instrumentacji:

Zaloguj się do platformy Azure przy użyciu polecenia $Connect-AzAccount.
Ustaw kontekst na subskrypcję z wartością Set-AzContext "<subscription ID>".
Następnie użyj:
1. $resource = Get-AzResource -Name "<resource name>" -ResourceType "Microsoft.Insights/components"
2. $details = Get-AzResource -ResourceId $resource.ResourceId
3. $details.Properties.InstrumentationKey

Aby wyświetlić listę wielu innych właściwości zasobu usługi Application Insights, użyj:

Get-AzApplicationInsights -ResourceGroupName Fabrikam -Name FabrikamProd | Format-List

Więcej właściwości jest dostępnych za pośrednictwem poleceń cmdlet:

Set-AzApplicationInsightsDailyCap
Set-AzApplicationInsightsPricingPlan
Get-AzApplicationInsightsApiKey
Get-AzApplicationInsightsContinuousExport

Zapoznaj się ze szczegółową dokumentacją parametrów dla tych poleceń cmdlet.

Uwaga

31 marca 2025 r. zostanie zakończone świadczenie pomocy technicznej dla pozyskiwania klucza instrumentacji. Pozyskiwanie klucza instrumentacji będzie nadal działać, ale nie udostępnimy już aktualizacji ani obsługi funkcji. Przejście do parametry połączenia w celu skorzystania z nowych funkcji.

Ustawianie przechowywania danych

Następujące trzy metody umożliwiają programowe ustawianie przechowywania danych w zasobie usługi Application Insights.

Ustawianie przechowywania danych przy użyciu poleceń programu PowerShell

Oto prosty zestaw poleceń programu PowerShell do ustawiania przechowywania danych dla zasobu usługi Application Insights:

$Resource = Get-AzResource -ResourceType Microsoft.Insights/components -ResourceGroupName MyResourceGroupName -ResourceName MyResourceName
$Resource.Properties.RetentionInDays = 365
$Resource | Set-AzResource -Force

Ustawianie przechowywania danych przy użyciu interfejsu REST

Aby uzyskać bieżące przechowywanie danych dla zasobu usługi Application Insights, możesz użyć narzędzia systemu operacyjnego ARMClient. Dowiedz się więcej o usłudze ARMClient z artykułów davida Ebbo i Daniela Bowbyesa. Oto przykład używany ARMClient do uzyskania bieżącego przechowywania:

armclient GET /subscriptions/00000000-0000-0000-0000-00000000000/resourceGroups/MyResourceGroupName/providers/microsoft.insights/components/MyResourceName?api-version=2018-05-01-preview

Aby ustawić przechowywanie, polecenie jest podobne PUT:

armclient PUT /subscriptions/00000000-0000-0000-0000-00000000000/resourceGroups/MyResourceGroupName/providers/microsoft.insights/components/MyResourceName?api-version=2018-05-01-preview "{location: 'eastus', properties: {'retentionInDays': 365}}"

Aby ustawić przechowywanie danych na 365 dni przy użyciu poprzedniego szablonu, uruchom polecenie:

New-AzResourceGroupDeployment -ResourceGroupName "<resource group>" `
       -TemplateFile .\template1.json `
       -retentionInDays 365 `
       -appName myApp

Ustawianie przechowywania danych przy użyciu skryptu programu PowerShell

Poniższy skrypt może również służyć do zmiany przechowywania. Skopiuj ten skrypt, aby zapisać go jako Set-ApplicationInsightsRetention.ps1.

Param(
    [Parameter(Mandatory = $True)]
    [string]$SubscriptionId,

    [Parameter(Mandatory = $True)]
    [string]$ResourceGroupName,

    [Parameter(Mandatory = $True)]
    [string]$Name,

    [Parameter(Mandatory = $True)]
    [string]$RetentionInDays
)
$ErrorActionPreference = 'Stop'
if (-not (Get-Module Az.Accounts)) {
    Import-Module Az.Accounts
}
$azProfile = [Microsoft.Azure.Commands.Common.Authentication.Abstractions.AzureRmProfileProvider]::Instance.Profile
if (-not $azProfile.Accounts.Count) {
    Write-Error "Ensure you have logged in before calling this function."    
}
$currentAzureContext = Get-AzContext
$profileClient = New-Object Microsoft.Azure.Commands.ResourceManager.Common.RMProfileClient($azProfile)
$token = $profileClient.AcquireAccessToken($currentAzureContext.Tenant.TenantId)
$UserToken = $token.AccessToken
$RequestUri = "https://management.azure.com/subscriptions/$($SubscriptionId)/resourceGroups/$($ResourceGroupName)/providers/Microsoft.Insights/components/$($Name)?api-version=2015-05-01"
$Headers = @{
    "Authorization"         = "Bearer $UserToken"
    "x-ms-client-tenant-id" = $currentAzureContext.Tenant.TenantId
}
## Get Component object via ARM
$GetResponse = Invoke-RestMethod -Method "GET" -Uri $RequestUri -Headers $Headers 

## Update RetentionInDays property
if($($GetResponse.properties | Get-Member "RetentionInDays"))
{
    $GetResponse.properties.RetentionInDays = $RetentionInDays
}
else
{
    $GetResponse.properties | Add-Member -Type NoteProperty -Name "RetentionInDays" -Value $RetentionInDays
}
## Upsert Component object via ARM
$PutResponse = Invoke-RestMethod -Method "PUT" -Uri "$($RequestUri)" -Headers $Headers -Body $($GetResponse | ConvertTo-Json) -ContentType "application/json"
$PutResponse

Ten skrypt może być następnie używany jako:

Set-ApplicationInsightsRetention `
        [-SubscriptionId] <String> `
        [-ResourceGroupName] <String> `
        [-Name] <String> `
        [-RetentionInDays <Int>]

Ustawianie dziennego limitu

Aby uzyskać właściwości dziennego limitu, użyj polecenia cmdlet Set-AzApplicationInsightsPricingPlan :

Set-AzApplicationInsightsDailyCap -ResourceGroupName <resource group> -Name <resource name> | Format-List

Aby ustawić właściwości dziennego limitu, użyj tego samego polecenia cmdlet. Aby na przykład ustawić limit na 300 GB dziennie:

Set-AzApplicationInsightsDailyCap -ResourceGroupName <resource group> -Name <resource name> -DailyCapGB 300

Możesz również użyć elementu ARMClient , aby pobrać i ustawić parametry dziennego limitu. Aby uzyskać bieżące wartości, użyj:

armclient GET /subscriptions/00000000-0000-0000-0000-00000000000/resourceGroups/MyResourceGroupName/providers/microsoft.insights/components/MyResourceName/CurrentBillingFeatures?api-version=2018-05-01-preview

Ustawianie dziennego czasu resetowania limitu

Ważne

Nie można już dostosować czasu resetowania dziennego limitu przy użyciu atrybutu ResetTime .

Ustawianie planu cenowego

Aby uzyskać bieżący plan cenowy, użyj polecenia cmdlet Set-AzApplicationInsightsPricingPlan :

Set-AzApplicationInsightsPricingPlan -ResourceGroupName <resource group> -Name <resource name> | Format-List

Aby ustawić plan cenowy, użyj tego samego polecenia cmdlet z określonym:-PricingPlan

Set-AzApplicationInsightsPricingPlan -ResourceGroupName <resource group> -Name <resource name> -PricingPlan Basic

Plan cenowy dla istniejącego zasobu usługi Application Insights można również ustawić przy użyciu poprzedniego szablonu usługi ARM, pomijając zasób "microsoft.insights/components" i dependsOn węzeł z zasobu rozliczeniowego. Aby na przykład ustawić go na plan na GB (wcześniej nazywany planem podstawowym), uruchom polecenie:

        New-AzResourceGroupDeployment -ResourceGroupName "<resource group>" `
               -TemplateFile .\template1.json `
               -priceCode 1 `
               -appName myApp

Element priceCode jest zdefiniowany jako:

priceCode	Planowanie
1	Na GB (wcześniej nazwany plan podstawowy)
2	Na węzeł (wcześniej nazywa się plan Enterprise)

Na koniec możesz użyć klienta ARMClient , aby uzyskać i ustawić plany cenowe i parametry dziennego limitu. Aby uzyskać bieżące wartości, użyj:

armclient GET /subscriptions/00000000-0000-0000-0000-00000000000/resourceGroups/MyResourceGroupName/providers/microsoft.insights/components/MyResourceName/CurrentBillingFeatures?api-version=2018-05-01-preview

Wszystkie te parametry można ustawić przy użyciu następujących metod:

armclient PUT /subscriptions/00000000-0000-0000-0000-00000000000/resourceGroups/MyResourceGroupName/providers/microsoft.insights/components/MyResourceName/CurrentBillingFeatures?api-version=2018-05-01-preview
"{'CurrentBillingFeatures':['Basic'],'DataVolumeCap':{'Cap':200,'ResetTime':12,'StopSendNotificationWhenHitCap':true,'WarningThreshold':90,'StopSendNotificationWhenHitThreshold':true}}"

Ten kod ustawia dzienny limit na 200 GB dziennie, skonfiguruj dzienny czas resetowania limitu do 12:00 UTC, wysyłaj wiadomości e-mail zarówno po osiągnięciu limitu, jak i na poziomie ostrzeżenia i ustaw próg ostrzeżenia na 90% limitu.

Dodawanie alertu dotyczącego metryki

Aby zautomatyzować tworzenie alertów dotyczących metryk, zobacz artykuł Szablon alertów dotyczących metryk.

Dodawanie testu dostępności

Aby zautomatyzować testy dostępności, zobacz artykuł Szablon alertów dotyczących metryk.

Dodawanie większej liczby zasobów

Aby zautomatyzować tworzenie dowolnego innego zasobu, utwórz przykład ręcznie, a następnie skopiuj i sparametryzuj kod z usługi Azure Resource Manager.

Otwórz usługę Azure Resource Manager. Przejdź w subscriptions/resourceGroups/<your resource group>/providers/Microsoft.Insights/components dół do zasobu aplikacji.

Składniki to podstawowe zasoby usługi Application Insights do wyświetlania aplikacji. Istnieją oddzielne zasoby dla skojarzonych reguł alertów i testów sieci Web dostępności.
Skopiuj kod JSON składnika do odpowiedniego miejsca w pliku template1.json.
Usuń następujące właściwości:
- id
- InstrumentationKey
- CreationDate
- TenantId
webtests Otwórz sekcje i alertrules i skopiuj kod JSON dla poszczególnych elementów do szablonu. Nie kopiuj z węzłów webtests lub alertrules . Przejdź do elementów znajdujących się pod nimi.

Każdy test internetowy ma skojarzą regułę alertu, więc musisz skopiować obie te elementy.
Wstaw ten wiersz w każdym zasobie:

"apiVersion": "2015-05-01",

Parametryzacja szablonu

Teraz musisz zastąpić określone nazwy parametrami. Aby sparametryzować szablon, należy napisać wyrażenia przy użyciu zestawu funkcji pomocnika.

Nie można sparametryzować tylko części ciągu, więc użyj polecenia concat() do kompilowania ciągów.

Poniżej przedstawiono przykłady podstawień, które chcesz utworzyć. Istnieje kilka wystąpień każdego podstawienia. W szablonie mogą być potrzebne inne osoby. W tych przykładach użyto parametrów i zmiennych zdefiniowanych w górnej części szablonu.

Znajdź	Replace with
`"hidden-link:/subscriptions/.../../components/MyAppName"`	`"[concat('hidden-link:',` `resourceId('microsoft.insights/components',` `parameters('appName')))]"`
`"/subscriptions/.../../alertrules/myAlertName-myAppName-subsId",`	`"[resourceId('Microsoft.Insights/alertrules', variables('alertRuleName'))]",`
`"/subscriptions/.../../webtests/myTestName-myAppName",`	`"[resourceId('Microsoft.Insights/webtests', parameters('webTestName'))]",`
`"myWebTest-myAppName"`	`"[variables(testName)]"'`
`"myTestName-myAppName-subsId"`	`"[variables('alertRuleName')]"`
`"myAppName"`	`"[parameters('appName')]"`
`"myappname"` (małe litery)	`"[toLower(parameters('appName'))]"`
`"<WebTest Name=\"myWebTest\" ...` `Url=\"http://fabrikam.com/home\" ...>"`	`[concat('<WebTest Name=\"',` `parameters('webTestName'),` `'\" ... Url=\"', parameters('Url'),` `'\"...>')]"`

Ustawianie zależności między zasobami

Platforma Azure powinna skonfigurować zasoby w ścisłej kolejności. Aby upewnić się, że jedna konfiguracja zostanie ukończona przed następnym rozpoczęciem, dodaj wiersze zależności:

W zasobie testu dostępności:

"dependsOn": ["[resourceId('Microsoft.Insights/components', parameters('appName'))]"],
W zasobie alertu dla testu dostępności:

"dependsOn": ["[resourceId('Microsoft.Insights/webtests', variables('testName'))]"],

Następne kroki

Zapoznaj się z innymi artykułami automatyzacji:

Tworzenie zasobu usługi Application Insights
Tworzenie testów internetowych.
Wyślij Diagnostyka Azure do usługi Application Insights.
Tworzenie adnotacji wydania.

Udostępnij za pośrednictwem