Esercitazione: Creare un runbook Python 3.8

Questa esercitazione illustra la creazione di un runbook Python 3.8 in Automazione di Azure. I runbook Python vengono compilati in Python 2.7 e 3.8 È possibile modificare direttamente il codice del runbook usando l'editor di testo nel portale di Azure.

• Creare un runbook Python semplice
• Testare e pubblicare il runbook
• Eseguire il processo del runbook e monitorarne lo stato
• Aggiornare il runbook per avviare una macchina virtuale di Azure con i parametri del runbook

Prerequisiti

Per completare questa esercitazione, è necessario:

• Una sottoscrizione di Azure. Se non è ancora disponibile, è possibile attivare i vantaggi del sottoscrittore MSDN o iscriversi per ottenere un account gratuito.

• Un account di Automazione che contiene il runbook ed esegue l'autenticazione con le risorse di Azure usando identità gestite. Quando si crea l'account di Automazione, viene creata automaticamente un'identità gestita.

• Una macchina virtuale di Azure. Durante questa esercitazione si avvierà e si arresterà questo computer, quindi non dovrebbe essere una macchina virtuale di produzione.

Creare un nuovo runbook

Per iniziare, creare un runbook semplice che restituisce il testo Hello World.

1. Nel portale di Azure aprire l'account di Automazione.

   La pagina Account di Automazione offre una rapida visualizzazione delle risorse in questo account. Dovresti già avere alcuni beni. La maggior parte di questi asset sono i moduli inclusi automaticamente in un nuovo account di Automazione.

   È anche necessario che sia abilitata un'identità gestita indicata nei prerequisiti. È possibile verificare che visualizzando la risorsa Identità in Impostazioni account.

2. Selezionare Runbook in Automazione processi per aprire l'elenco dei runbook.

3. Selezionare Crea un runbook per creare un nuovo runbook.

4. Assegnare al runbook il nome MyFirstRunbook-Python.

5. Selezionare Python per il tipo di runbook.

6. Selezionare Python 3.8 per la versione di runtime.

7. Selezionare Crea per creare il runbook e aprire l'editor di testo.

Aggiungere codice al runbook

Ora si aggiunge un semplice comando per stampare il testo Hello World.

print("Hello World!")

Selezionare Salva per salvare il runbook.

Testare il runbook

Prima di pubblicare il runbook per renderlo disponibile nell'ambiente di produzione, è necessario testarlo per assicurarsi che funzioni correttamente. Quando si testa un runbook, è necessario eseguire la versione bozza e visualizzarne l'output in modo interattivo.

1. Selezionare Il riquadro Test per aprire il riquadro Test .

2. Selezionare Avvia per avviare il test. Questa opzione deve essere l'unica opzione abilitata.

3. Viene creata un'attività del runbook e ne viene visualizzato lo stato. Lo stato iniziale del processo è In coda, indicando che è in attesa della disponibilità di un ruolo di lavoro runbook nel cloud. Lo stato passa ad Avvio in corso quando un ruolo di lavoro richiede il processo e quindi a In esecuzione quando l'esecuzione del runbook viene effettivamente avviata.

4. Al termine del processo del runbook, viene visualizzato l'output. In questo caso, dovrebbe essere visualizzato Hello World.

5. Chiudere il riquadro Test per tornare all'area di disegno.

Pubblicare e avviare il runbook

Il runbook che hai creato è ancora in modalità bozza. È necessario pubblicarlo prima di poterlo eseguire nell'ambiente di produzione. Quando si pubblica un runbook, viene sovrascritta la versione pubblicata esistente con la versione bozza. In questo caso, non esiste ancora una versione pubblicata perché il runbook è appena stato creato.

1. Selezionare Pubblica per pubblicare il runbook e quindi Sì quando richiesto.

2. Se si chiude il riquadro MyFirstRunbook_python, si torna alla pagina Runbooks in cui verrà visualizzato no stato di creazionePubblicato.

3. Selezionare il nome MyFirstRunbook-Python nell'elenco. Si tornerà al riquadro MyFirstRunbook-Python .

   Le opzioni nella parte superiore consentono di avviare il runbook, visualizzare il runbook, modificare il runbook, pianificarlo per iniziare in un determinato momento in futuro e altre azioni.

4. Selezionare Start e quindi OK all'apertura del riquadro Avvia runbook .

5. Verrà aperto un riquadro Processo per il processo del runbook creato. È possibile chiudere questo riquadro, ma mantenerlo aperto, in modo da poter controllare lo stato di avanzamento del processo.

6. Lo stato del processo viene visualizzato nel campo Stato in Informazioni di base. I valori qui corrispondono ai valori di stato quando è stato testato il runbook.

7. Quando lo stato del runbook è Completato, selezionare la scheda Output . Nella scheda Output è possibile visualizzare Hello World.

8. Chiudere la scheda Output .

9. Selezionare la scheda Tutti i log per visualizzare i flussi per il processo runbook. Nel flusso di output dovrebbe essere visualizzato solo Hello World. Questa scheda tuttavia può mostrare altri flussi per un processo runbook, ad esempio Dettagliato ed Errore, se il runbook esegue la scrittura in questi flussi.

10. Chiudere il riquadro Processi per tornare al riquadro MyFirstRunbook-Python .

11. Selezionare la risorsa Processi per aprire la pagina della risorsa Processi per questo runbook. Questa pagina elenca tutti i processi creati da questo runbook. Dovresti vedere solo un lavoro elencato poiché il lavoro è stato eseguito una sola volta.

12. È possibile selezionare questa attività per aprire lo stesso riquadro Attività visualizzato quando hai avviato il runbook. Questo riquadro consente di tornare indietro nel tempo e visualizzare i dettagli di qualsiasi processo creato per un runbook specifico.

Aggiungere l'autenticazione per gestire le risorse di Azure

Il runbook è stato testato e pubblicato, ma finora non esegue alcuna attività utile. Si vuole che gestisca le risorse di Azure. Per gestire le risorse, lo script deve eseguire l'autenticazione.

Il modo consigliato per eseguire l'autenticazione è con l'identità gestita. Quando si crea un account di Automazione di Azure, viene creata automaticamente un'identità gestita.

Per usare questi esempi, aggiungere i pacchetti seguenti nella risorsa Pacchetti Python dell'account di Automazione. È possibile aggiungere i file WHL per questi pacchetti con questi collegamenti.

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

Quando si aggiungono questi pacchetti, selezionare una versione di runtime corrispondente al runbook.

Annotazioni

Il codice seguente è stato testato con la versione di runtime 3.8.

Identità gestita

Per usare l'identità gestita, assicurarsi che sia abilitata:

• Per verificare se l'identità gestita è abilitata per l'account di Automazione, vai al tuo account di Automazione>Impostazioni account>Identità e imposta lo Stato su Abilitato.
• L'identità gestita ha un ruolo assegnato per gestire la risorsa. In questo esempio di gestione di una risorsa macchina virtuale, aggiungere il ruolo "Collaboratore macchina virtuale" nel gruppo di risorse che contiene la macchina virtuale. Per altre informazioni, vedere Assegnare ruoli di Azure tramite il portale di Azure

Dopo aver configurato il ruolo di gestione dell'identità, è possibile iniziare ad aggiungere codice.

1. Aprire l'editor di testo selezionando Modifica nel riquadro MyFirstRunbook-Python .

2. Aggiungere il codice seguente per l'autenticazione in 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)

Aggiungere codice per creare il client di calcolo Python e avviare la macchina virtuale

Per usare le macchine virtuali di Azure, creare un'istanza del client di calcolo di Azure per 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.')

Dove MyResourceGroup è il nome del gruppo di risorse che contiene la macchina virtuale e TestVM è il nome della macchina virtuale che si vuole avviare.

Testare ed eseguire di nuovo il runbook per verificare che avvii la macchina virtuale.

Usare i parametri di input

Il runbook usa attualmente valori hardcoded per i nomi del gruppo di risorse e della macchina virtuale. Aggiungere ora il codice che ottiene questi valori dai parametri di input.

Usare la sys.argv variabile per ottenere i valori dei parametri. Aggiungere il codice seguente al runbook immediatamente dopo le altre istruzioni import:

import sys

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

Questo codice importa il sys modulo e crea due variabili per contenere il gruppo di risorse e i nomi delle macchine virtuali. Si noti che l'elemento dell'elenco di argomenti, sys.argv[0], è il nome dello script e non è input dall'utente.

È ora possibile modificare le ultime due righe del runbook per usare i valori dei parametri di input anziché usare valori hardcoded:

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

Quando si avvia un runbook Python, dal riquadro Test o come runbook pubblicato, è possibile immettere i valori per i parametri nella pagina Avvia runbook in Parametri.

Dopo aver iniziato a immettere un valore nella prima casella, viene visualizzato un secondo e così via, in modo da poter immettere il numero di valori dei parametri necessario.

I valori sono disponibili per lo script nella sys.argv matrice come nel codice appena aggiunto.

Immettere il nome del gruppo di risorse come valore per il primo parametro e il nome della macchina virtuale da avviare come valore del secondo parametro.

Selezionare OK per avviare il runbook. Il runbook viene eseguito e avvia la macchina virtuale specificata.

Gestione degli errori in Python

È anche possibile usare le convenzioni seguenti per recuperare vari flussi dai runbook Python, inclusi i flussi WARNING, ERROR e DEBUG.

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

Nell'esempio seguente viene illustrata questa convenzione utilizzata in un try...except blocco .

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

Passaggi successivi

• Per altre informazioni sui tipi di runbook, sui relativi vantaggi e limitazioni, vedere Tipi di runbook di Automazione di Azure.

• Per informazioni sullo sviluppo per Azure con Python, vedere Azure per sviluppatori Python.

• Per visualizzare i runbook di esempio di Python 3, consultare il repository di Automazione di Azure su GitHub.