Managing Azure VM Services with Python: Start and Check Service Status with Azure Run Command

This guide explains how to use Python and the Azure SDK to start a service on an Azure VM and check its status. We’ll use the RunCommandInput from the Azure Compute Management Client to send shell commands directly to the VM, allowing us to manage services (such as Nginx) without logging into the VM manually.

Prerequisites

1. Azure Subscription: You’ll need an Azure subscription. Sign up here.
2. Virtual Machine (VM): Ensure the VM you want to manage is created and accessible within the Azure subscription.
3. Python Environment: Python 3.6 or higher is required. You can download it here.
4. Azure SDK Libraries:
   • Install the required Azure libraries via pip: “pip install azure-identity azure-mgmt-compute“

Overview of the Script

This script will:

1. Authenticate with Azure using DefaultAzureCredential.
2. Define a Run Command to start the Nginx service on the VM and check its status.
3. Run the Command on the VM and retrieve the output.
4. Parse the Output to display both stdout and stderr messages in JSON format.

Code Walkthrough

Here’s the complete code:

import json
from azure.identity import DefaultAzureCredential
from azure.mgmt.compute import ComputeManagementClient
from azure.mgmt.compute.models import RunCommandInput

# Define subscription and resource details
subscription_id = "{ YOUR SUBSCRIPTION }"
resource_group_name = "{ RESOURCE GROUP NAME }"
vm_name = "{ YOUR VM NAME }"

# Initialize Azure credentials and client
credential = DefaultAzureCredential()
compute_client = ComputeManagementClient(credential, subscription_id)

# Define the service to manage (in this case, Nginx)
services_os = "nginx"

# Define the command to run on the VM
command = RunCommandInput(
    command_id='RunShellScript',
    script=[
        f'systemctl start {services_os}',
        f'systemctl is-active {services_os}'
    ]
)

# Execute the command
stop_nginx = compute_client.virtual_machines.begin_run_command(
    resource_group_name, vm_name, command
)
result = stop_nginx.result()

# Parse the output
output_messages = []
for message in result.value:
    stdout_start = message.message.find("[stdout]") + len("[stdout]\n")
    stderr_start = message.message.find("[stderr]") + len("[stderr]\n")

    stdout = message.message[stdout_start:stderr_start - len("[stderr]\n")].strip()
    stderr = message.message[stderr_start:].strip()

    output_message = {
        "code": message.code,
        "stdout": stdout,
        "stderr": stderr
    }
    output_messages.append(output_message)

# Print the result in JSON format
result_dict = {"output": output_messages}
print(json.dumps(result_dict, indent=4))

Explanation of Each Step

1. Authentication: Using DefaultAzureCredential to authenticate with Azure allows for seamless authentication, accommodating multiple methods, including environment variables and managed identities.
2. Define Command: The RunCommandInput object specifies the command to start the Nginx service and check its active status.
3. Execute the Command: We call begin_run_command() on the compute_client.virtual_machines object to send the command to the specified VM.
4. Parsing Output: The output message is parsed to extract stdout and stderr for each response, organizing them into a dictionary.
5. Display Result: The final output is printed in JSON format for easy readability.

Running the Script

To run the script, use the following command in your terminal:

python manage_service_on_vm.py

Sample Output

On successful execution, the output will look something like this:

{
    "output": [
        {
            "code": "ProvisioningState/succeeded",
            "stdout": "active",
            "stderr": ""
        }
    ]
}

Use Cases

This script can be used for various scenarios:

• Automated Service Management: Ideal for managing services on remote VMs directly from code.
• Health Checks: Running this script on a schedule allows you to check service status automatically and ensure high availability.
• DevOps Pipelines: This script can be integrated into CI/CD pipelines for automated environment setup and teardown.

Conclusion

Using the Azure SDK’s RunCommandInput, we can streamline the management of VM services directly from a Python script, saving time and reducing the need for manual VM access. This approach is particularly useful for automated management and monitoring of services on remote VMs.