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

Den här självstudien visar hur du skapar en Python 3-runbook (förhandsversion) i Azure Automation. Python-runbooks kompileras under Python 2 och 3. Du kan redigera koden för runbooken direkt med hjälp av textredigeraren i Azure Portal.

Förutsättningar

För att göra den här självstudien behöver du följande:

• 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 Azure som runbooken ska ligga under och som ska användas för autentisering mot Azure-resurser. Det här kontot måste ha behörighet att starta och stoppa den virtuella datorn. Kör som-kontot krävs för den här självstudien.

• En virtuell dator i Azure. I den här självstudien startar och stoppar du den här datorn, så det 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 autentiseringstillgången för Kör som-kontot som anges i förutsättningarna.

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

3. Välj Lägg till en runbook för att skapa en ny runbook.

4. Ge runbooken namnet MyFirstRunbook-Python.

5. Välj Python 3 som Runbook-typ.

6. 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önster för att öppna testfönstret.

2. Välj Starta för att starta testet. Detta bör vara det enda aktiverade alternativet.

3. Ett runbook-jobb skapas och dess status visas. Jobbstatusen börjar som I kö, vilket anger att det väntar på att en Runbook Worker i molnet ska bli tillgänglig. Den ändras till Startar när en arbetsroll gör anspråk på 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 inte någon publicerad version än eftersom du precis har skapat runbooken.

1. Välj Publicera för att publicera runbooken och sedan Ja när du tillfrågas.

2. Om du rullar åt vänster för att visa runbooken på runbook-sidan bör du se redigeringsstatusen Publicerad.

3. Rulla tillbaka till höger för att visa fönstret för MyFirstRunbook-Python3.

   Med alternativen längst upp kan du starta runbooken, visa runbooken eller schemalägga den så att den startar någon gång i framtiden.

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

5. Ett jobbfönster öppnas för runbook-jobbet som du skapade. Du kan stänga det här fönstret, men låt det vara öppet så att du kan titta på jobbets förlopp.

6. Jobbstatusen visas i Jobbsammanfattning och matchar de statusar som du såg när du testade runbooken.

7. När runbook-statusen visar Slutfört väljer du Utdata. Fönstret Utdata öppnas, där du kan se Hello World .

8. Stäng fönstret Utdata.

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

10. Stäng fönstret Strömmar och fönstret Jobb för att återgå till fönstret MyFirstRunbook-Python3.

11. Välj Jobb för att öppna sidan 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. För att göra detta måste skriptet autentisera med autentiseringsautentiseringsuppgifter för Kör som-kontot från ditt Automation-konto.

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

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

   import os
   from azure.mgmt.compute import ComputeManagementClient
   import azure.mgmt.resource
   import automationassets
   
   def get_automation_runas_credential(runas_connection):
       from OpenSSL import crypto
       import binascii
       from msrestazure import azure_active_directory
       import adal
   
       # Get the Azure Automation RunAs service principal certificate
       cert = automationassets.get_automation_certificate("AzureRunAsCertificate")
       pks12_cert = crypto.load_pkcs12(cert)
       pem_pkey = crypto.dump_privatekey(crypto.FILETYPE_PEM,pks12_cert.get_privatekey())
   
       # Get run as connection information for the Azure Automation service principal
       application_id = runas_connection["ApplicationId"]
       thumbprint = runas_connection["CertificateThumbprint"]
       tenant_id = runas_connection["TenantId"]
   
       # Authenticate with service principal certificate
       resource ="https://management.core.windows.net/"
       authority_url = ("https://login.microsoftonline.com/"+tenant_id)
       context = adal.AuthenticationContext(authority_url)
       return azure_active_directory.AdalAuthentication(
       lambda: context.acquire_token_with_client_certificate(
               resource,
               application_id,
               pem_pkey,
               thumbprint)
       )
   
   # Authenticate to Azure using the Azure Automation RunAs service principal
   runas_connection = automationassets.get_automation_connection("AzureRunAsConnection")
   azure_credential = get_automation_runas_credential(runas_connection)
   

Lägga till kod för att skapa En Python Compute-klient och starta den virtuella datorn

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

Använd beräkningsklienten för att starta den virtuella datorn. Lägg till följande kod i runbooken:

# Initialize the compute management client with the Run As credential and specify the subscription to work against.
compute_client = ComputeManagementClient(
    azure_credential,
    str(runas_connection["SubscriptionId"])
)


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

Där MyResourceGroup är namnet på resursgruppen som innehåller den virtuella datorn och är namnet på den virtuella dator som du vill TestVM 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 sys.argv variabeln för att hämta parametervärdena. Lägg till följande kod i runbooken direkt efter de andra import isatserna:

import sys

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

Detta importerar modulen sys och skapar två variabler som ska innehålla resursgruppen och namnen på den virtuella datorn. Observera att elementet i sys.argv[0] argumentlistan, , ä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.start(
    resource_group_name, vm_name)
async_vm_start.wait()

När du startar en Python-runbook, antingen från testfönstret eller som en publicerad runbook, kan du ange värden för parametrarna 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 just lade till.

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

Starta runbooken genom att välja OK. Runbooken körs och startar den virtuella dator som du har angett.

<a name="error-handling-in-python">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 STRÖMMAR FÖR VARNING, FEL och FELSÖKNING.

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

• Mer information om runbook-typer, deras fördelar och begränsningar finns i Azure Automation runbook-typer.

• Mer information om hur du utvecklar för Azure med Python finns i Azure för Python-utvecklare.

• Om du vill visa Exempel på Python 3-runbooks kan du Azure Automation GitHub-lagringsplatsen.