Självstudie: Skapa en Python 3.8-runbook

Den här självstudien beskriver hur du skapar en Python 3.8-runbook 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-portalen.

Förutsättningar

För att slutföra denna handledning behöver du:

• Ett Azure-abonnemang. Om du inte har något ännu 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 till Azure-resurser med hjälp av hanterade identiteter. En hanterad identitet skapas automatiskt åt dig när du skapar Automation-kontot.

• En virtuell Azure-maskin. Under den här handledningen startar och stoppar du den här virtuella maskinen, så det bör inte vara en produktions-VM.

Skapa en ny runbook

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

1. Öppna ditt Automation-konto i Azure-portalen.

   På sidan Automation-konto får du en snabb överblick över resurserna i det här kontot. Du bör redan ha några tillgångar. De flesta av dessa tillgångar är de moduler som automatiskt ingår i ett nytt Automation-konto.

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

2. Välj Runbooks under Process Automation 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ägg till kod i runboken

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 runbooken för att göra den tillgänglig i produktionsmiljö vill du testa den för att säkerställa dess korrekta funktionalitet. 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 Starta för att starta testet. Det här alternativet bör 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-arbetare i molnet ska bli tillgänglig. Den ändras till Starta när en arbetare gör anspråk på jobbet och sedan Körs när runbooken faktiskt börjar köras.

4. När runbook-jobbet har slutförts 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 körningsboken

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 den, redigera den, schemalägga den för att starta vid ett senare tillfälle, samt utföra andra åtgärder.

4. Välj Start och välj 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 kan du se Hello World.

8. Stäng fliken Utdata .

9. Välj fliken Alla loggar för att visa dataströ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 sidan Jobbresurs för den här runbooken. På den här sidan visas alla jobb som skapats av den här runbooken. Du bör bara se ett jobb i listan 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 den här panelen kan du gå tillbaka i tiden och visa information om alla jobb som har skapats för en specifik runbook.

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

Du har testat och publicerat din runbook, men hittills har den inte gjort något användbart. Du vill att den ska hantera Azure-resurser. För att hantera resurser måste skriptet autentiseras.

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 Packages-resursen för Automation-kontot. Du kan lägga till WHL-filerna för dessa paket med dessa länkar.

• azure-core
• azure-identity
• azure-mgmt-compute
• azure-mgmt-core
• msal
• typing-extensions

När du lägger till dessa paket väljer du en körmiljöversion som matchar din körbok.

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> för > och anger Status till På.
• Den hanterade identiteten har en roll tilldelad 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-portalen

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.')

Var 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 omedelbart 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 matas in av 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 sekund 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 den kod som du nyss 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.

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

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

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

• För att se exempel på Python 3-runbooks, besök Azure Automation GitHub-lagringsplatsen.