Självstudie: Skapa en Python 3.8-runbook (förhandsversion)

Den här självstudien vägleder dig genom skapandet av en Python 3.8-runbook (förhandsversion) i Azure Automation. Python-runbooks kompileras under Python 2.7 och 3.8 Du kan redigera koden för runbooken direkt med hjälp av textredigeraren i Azure Portal.

  • Skapa en enkel Python-runbook
  • Testa och publicera runbooken
  • Köra och spåra runbook-jobbets status
  • Uppdatera runbooken för att starta en virtuell Azure-dator med runbook-parametrar

Förutsättningar

För att slutföra den här kursen behöver du:

  • En Azure-prenumeration. Om du inte redan har ett konto kan du aktivera dina MSDN-prenumerantförmåner eller registrera dig för ett kostnadsfritt konto.

  • Ett Automation-konto för att lagra runbooken och autentisera mot Azure-resurser med hjälp av hanterade identiteter. En hanterad identitet skapas automatiskt åt dig när du skapar Automation-kontot.

  • En virtuell dator i Azure. I den här självstudien startar och stoppar du den här datorn, så den bör inte vara en virtuell produktionsdator.

Skapa en ny runbook

Du börjar med att skapa en enkel runbook som matar ut texten Hello World.

  1. Öppna ditt Automation-konto på Azure Portal.

    Automation-kontosidan innehåller en snabb översikt över resurserna i det här kontot. Du bör redan ha vissa tillgångar. De flesta av dessa tillgångar är de moduler som ingår automatiskt i ett nytt Automation-konto.

    Du bör också ha en aktiverad hanterad identitet som anges i förutsättningarna. Du kan kontrollera det genom att visa identitetsresursen under Kontoinställningar.

  2. Välj Runbooks under Processautomatisering för att öppna listan över runbooks.

  3. Välj Skapa en runbook för att skapa en ny runbook.

  4. Ge runbooken namnet MyFirstRunbook-Python.

  5. Välj Python som Runbook-typ.

  6. Välj Python 3.8 som Körningsversion.

  7. Välj Skapa för att skapa runbooken och öppna textredigeraren.

Lägga till kod i runbooken

Nu lägger du till ett enkelt kommando för att skriva ut texten Hello World.

print("Hello World!")

Välj Spara för att spara runbooken.

Testa runbooken

Innan du publicerar runbook-jobbet så att den blir tillgänglig i produktionsmiljön testar du den och kontrollerar att den fungerar som den ska. När du testar en runbook kör du dess utkastversion och visar dess utdata interaktivt.

  1. Välj testfönstret för att öppna fönstret Test .

  2. Välj Start för att starta testet. Det här alternativet ska vara det enda aktiverade alternativet.

  3. Ett runbook-jobb skapas och dess status visas. Jobbstatusen börjar som I kö, vilket indikerar att den väntar på att en Runbook Worker i molnet ska bli tillgänglig. Den ändras till Startar när en arbetare begär jobbet och sedan Körs när runbooken faktiskt börjar köras.

  4. När runbook-jobbet är klart visas dess utdata. I det här fallet bör du se Hello World.

  5. Stäng fönstret Test för att återgå till arbetsytan.

Publicera och starta runbooken

Runbooken som du skapade är fortfarande i utkastläge. Du måste publicera den innan du kan köra den i produktion. När du publicerar en runbook skriver du över den befintliga publicerade versionen med utkastversionen. I det här fallet har du ingen publicerad version ännu eftersom du precis har skapat runbooken.

  1. Välj Publicera för att publicera runbooken och sedan Ja när du uppmanas till det.

  2. Om du stänger fönstret MyFirstRunbook_python är du tillbaka på sidan Runbooks där du bör se redigeringsstatusenPublicerad.

  3. Välj namnet MyFirstRunbook-Python i listan. Gå tillbaka till fönstret MyFirstRunbook-Python .

    Med alternativen överst kan du starta runbooken, visa runbooken, redigera runbooken, schemalägga den så att den startar någon gång i framtiden och andra åtgärder.

  4. Välj Start och sedan OK när fönstret Starta Runbook öppnas.

  5. Ett jobbfönster öppnas för det Runbook-jobb som du skapade. Du kan stänga det här fönstret, men låt oss hålla det öppet så att du kan se jobbets förlopp.

  6. Jobbstatusen visas i fältet Status under Essentials. Värdena här matchar statusvärdena när du testade runbooken.

  7. När runbook-statusen visar Slutförd väljer du fliken Utdata . På fliken Utdata visas Hello World.

  8. Stäng fliken Utdata .

  9. Välj fliken Alla loggar för att visa strömmar för runbook-jobbet. Du bör bara se Hello World i utdataströmmen. Den här fliken kan dock visa andra strömmar för ett Runbook-jobb, till exempel Utförligt och Fel, om runbooken skriver till dem.

  10. Stäng fönstret Jobb för att återgå till fönstret MyFirstRunbook-Python .

  11. Välj Jobbresurs för att öppna resurssidan Jobb för den här runbooken. På den här sidan visas alla jobb som skapats av den här runbooken. Nu bör du endast se ett jobb eftersom du bara körde jobbet en gång.

  12. Du kan välja det här jobbet för att öppna samma jobbfönster som du visade när du startade runbooken. I det här fönstret kan du gå tillbaka i tiden och visa information om alla jobb som har skapats för en viss runbook.

Lägga till autentisering för att hantera Azure-resurser

Du har testat och publicerat din runbook, men hittills gör den egentligen inget användbart. Du vill att den ska hantera Azure-resurser. Skriptet måste autentiseras för att hantera resurser.

Det rekommenderade sättet att autentisera är med hanterad identitet. När du skapar ett Azure Automation konto skapas automatiskt en hanterad identitet åt dig.

Om du vill använda de här exemplen lägger du till följande paket i Python-paketresursen för Automation-kontot. Du kan lägga till WHL-filerna för dessa paket med dessa länkar.

När du lägger till dessa paket väljer du en körningsversion som matchar din runbook.

Anteckning

Följande kod testades med körningsversion 3.8.

Hanterad identitet

Om du vill använda hanterad identitet kontrollerar du att den är aktiverad:

  • Om du vill kontrollera om den hanterade identiteten är aktiverad för Automation-kontot går du till dinIdentitet för Automation-kontoinställningar>> och anger Status till .
  • Den hanterade identiteten har en roll som tilldelats för att hantera resursen. I det här exemplet på hantering av en virtuell datorresurs lägger du till rollen "Virtuell datordeltagare" i resursgruppen som innehåller den virtuella datorn. Mer information finns i Tilldela Azure-roller med hjälp av Azure Portal

När rollen hantera identitet har konfigurerats kan du börja lägga till kod.

  1. Öppna textredigeraren genom att välja Redigera i fönstret MyFirstRunbook-Python .

  2. Lägg till följande kod för att autentisera till Azure:

#!/usr/bin/env python3
from azure.identity import DefaultAzureCredential
from azure.mgmt.compute import ComputeManagementClient

SUBSCRIPTION_ID="YOUR_SUBSCRIPTION_ID"

azure_credential = DefaultAzureCredential()

import os
import requests
# printing environment variables
endpoint = os.getenv('IDENTITY_ENDPOINT')+"?resource=https://management.azure.com/"
identityHeader = os.getenv('IDENTITY_HEADER')
payload={}
headers = {
'X-IDENTITY-HEADER' : identityHeader,
'Metadata' : True
}
response = requests.get(endpoint, headers)
print(response.text)

Lägg till kod för att skapa Python Compute-klienten och starta den virtuella datorn

Om du vill arbeta med virtuella Azure-datorer skapar du en instans av Azure Compute-klienten för Python.

# Initialize client with the credential and subscription.
compute_client = ComputeManagementClient(
    azure_credential,
    SUBSCRIPTION_ID
)

print('\nStart VM')
async_vm_start = compute_client.virtual_machines.begin_start(
    "MyResourceGroup", "TestVM")
async_vm_start.wait()
print('\nFinished start.')

Där MyResourceGroup är namnet på resursgruppen som innehåller den virtuella datorn och TestVM är namnet på den virtuella dator som du vill starta.

Testa och kör runbooken igen för att se att den startar den virtuella datorn.

Använda indataparametrar

Runbooken använder för närvarande hårdkodade värden för namnen på resursgruppen och den virtuella datorn. Nu ska vi lägga till kod som hämtar dessa värden från indataparametrar.

Du använder variabeln sys.argv för att hämta parametervärdena. Lägg till följande kod i runbooken direkt efter de andra import instruktionerna:

import sys

resource_group_name = str(sys.argv[1])
vm_name = str(sys.argv[2])

Den här koden importerar modulen sys och skapar två variabler för resursgruppen och VM-namnen. Observera att elementet i argumentlistan, sys.argv[0], är namnet på skriptet och inte är indata från användaren.

Nu kan du ändra de två sista raderna i runbooken så att de använder indataparametervärdena i stället för att använda hårdkodade värden:

async_vm_start = compute_client.virtual_machines.begin_start(
    resource_group_name, vm_name)
async_vm_start.wait()

När du startar en Python-runbook, antingen från fönstret Test eller som en publicerad runbook, kan du ange värdena för parametrar på sidan Starta Runbook under Parametrar.

När du har börjat ange ett värde i den första rutan visas en andra, och så vidare, så att du kan ange så många parametervärden som behövs.

Värdena är tillgängliga för skriptet i matrisen sys.argv som i koden som du precis lade till.

Ange namnet på resursgruppen som värde för den första parametern och namnet på den virtuella datorn som ska startas som värdet för den andra parametern.

Ange parametervärden

Välj OK för att starta runbooken. Runbooken körs och startar den virtuella dator som du angav.

Felhantering i Python

Du kan också använda följande konventioner för att hämta olika strömmar från dina Python-runbooks, inklusive WARNING-, ERROR- och DEBUG-strömmar.

print("Hello World output")
print("ERROR: - Hello world error")
print("WARNING: - Hello world warning")
print("DEBUG: - Hello world debug")
print("VERBOSE: - Hello world verbose")

I följande exempel visas den här konventionen som används i ett try...except block.

try:
    raise Exception('one', 'two')
except Exception as detail:
    print ('ERROR: Handling run-time error:', detail)

Nästa steg