Självstudie: Distribuera en virtuell dator i azure public MEC med hjälp av Python SDK

Artikel
11/22/2022

I den här självstudien använder du Python SDK för att distribuera resurser i Azure public multi-access edge compute (MEC). Självstudien innehåller Python-kod för att distribuera en virtuell dator (VM) och dess beroenden i azure public MEC.

Information om Python-SDK:er finns i Azure-bibliotek för Python-användningsmönster.

I den här självstudien lär du dig att:

Installera nödvändiga Azure-bibliotekspaket
Etablera en virtuell dator
Kör skriptet i utvecklingsmiljön
Skapa en hoppserver i den associerade regionen
Få åtkomst till de virtuella datorerna

Förutsättningar

Om du inte har någon Azure-prenumeration skapar du ett kostnadsfritt konto innan du börjar.
Lägg till en tillåten prenumeration på ditt Azure-konto, vilket gör att du kan distribuera resurser i azure public MEC. Om du inte har en aktiv tillåten prenumeration kontaktar du azures offentliga MEC-produktteam.
Konfigurera Python i din lokala utvecklingsmiljö genom att följa anvisningarna i Konfigurera din lokala Python-utvecklingsmiljö för Azure. Se till att du skapar ett huvudnamn för tjänsten för lokal utveckling och skapar och aktiverar en virtuell miljö för det här självstudieprojektet.

Använd Bash-miljön i Azure Cloud Shell. Mer information finns i Snabbstart för Bash i Azure Cloud Shell.
Om du föredrar att köra CLI-referenskommandon lokalt installerar du Azure CLI. Om du kör i Windows eller macOS kan du köra Azure CLI i en Docker-container. Mer information finns i Så här kör du Azure CLI i en Docker-container.
- Om du använder en lokal installation loggar du in på Azure CLI med hjälp av kommandot az login. Slutför autentiseringsprocessen genom att följa stegen som visas i terminalen. Andra inloggningsalternativ finns i Logga in med Azure CLI.
- När du uppmanas att installera Azure CLI-tillägget vid första användningen. Mer information om tillägg finns i Använda tillägg med Azure CLI.
- Kör az version om du vill hitta versionen och de beroende bibliotek som är installerade. Om du vill uppgradera till den senaste versionen kör du az upgrade.

Installera nödvändiga Azure-bibliotekspaket

Skapa en fil med namnet requirements.txt som visar de hanteringsbibliotek som används i det här exemplet.

azure-mgmt-resource
azure-mgmt-compute
azure-mgmt-network
azure-identity
azure-mgmt-extendedlocation==1.0.0b2

Öppna en kommandotolk med den virtuella miljön aktiverad och installera hanteringsbiblioteken i requirements.txt.
```
pip install -r requirements.txt
```

Etablera en virtuell dator

Skapa en Python-fil med namnet provision_vm_edge.py och fyll i den med följande Python-skript. Skriptet distribuerar den virtuella datorn och dess associerade beroende i azure public MEC. Kommentarerna i skriptet förklarar informationen.

# Import the needed credential and management objects from the libraries.
from azure.identity import AzureCliCredential
from azure.mgmt.resource import ResourceManagementClient
from azure.mgmt.network import NetworkManagementClient
from azure.mgmt.compute import ComputeManagementClient
import os

print(f"Provisioning a virtual machine...some operations might take a minute or two.")

# Acquire a credential object using CLI-based authentication.
credential = AzureCliCredential()

# Retrieve subscription ID from environment variable.
subscription_id = os.environ["AZURE_SUBSCRIPTION_ID"]

# Step 1: Provision a resource group

# Obtain the management object for resources, using the credentials from the CLI login.
resource_client = ResourceManagementClient(credential, subscription_id)

# Constants we need in multiple places: the resource group name, the region and the public mec location
# in which we provision resources. Populate the variables with appropriate values. 
RESOURCE_GROUP_NAME = "PythonAzureExample-VM-rg"
LOCATION = "<region>"
PUBLIC_MEC_LOCATION = "<edgezone id>"
USERNAME = "azureuser"
PASSWORD = "<password>"
# Provision the resource group.
rg_result = resource_client.resource_groups.create_or_update(RESOURCE_GROUP_NAME,
   {
       "location": LOCATION
   }
)

print(f"Provisioned resource group {rg_result.name} in the {rg_result.location} region")

# For details on the previous code, see Example: Use the Azure libraries to provision a resource group
# at https://learn.microsoft.com/azure/developer/python/azure-sdk-example-resource-group

# Step 2: Provision a virtual network

# A virtual machine requires a network interface client (NIC). A NIC requires
# a virtual network and subnet along with an IP address. Therefore, we must provision
# these downstream components first, then provision the NIC, after which we
# can provision the VM.

# Network and IP address names
VNET_NAME = "python-example-vnet-edge"
SUBNET_NAME = "python-example-subnet-edge"
IP_NAME = "python-example-ip-edge"
IP_CONFIG_NAME = "python-example-ip-config-edge"
NIC_NAME = "python-example-nic-edge"

# Obtain the management object for networks
network_client = NetworkManagementClient(credential, subscription_id)

# Provision the virtual network and wait for completion
poller = network_client.virtual_networks.begin_create_or_update(RESOURCE_GROUP_NAME,
    VNET_NAME,
    {
        "location": LOCATION,
        "extendedLocation": {"type": "EdgeZone", "name": PUBLIC_MEC_LOCATION},
        "address_space": {
            "address_prefixes": ["10.1.0.0/16"]
        }
    }
)

vnet_result = poller.result()

print(f"Provisioned virtual network {vnet_result.name} with address prefixes {vnet_result.address_space.address_prefixes}")

# Step 3: Provision the subnet and wait for completion
poller = network_client.subnets.begin_create_or_update(RESOURCE_GROUP_NAME, 
    VNET_NAME, SUBNET_NAME,
    { "address_prefix": "10.1.0.0/24" }
)
subnet_result = poller.result()

print(f"Provisioned virtual subnet {subnet_result.name} with address prefix {subnet_result.address_prefix}")

# Step 4: Provision an IP address and wait for completion
# Only the standard public IP SKU is supported at EdgeZones
poller = network_client.public_ip_addresses.begin_create_or_update(RESOURCE_GROUP_NAME,
    IP_NAME,
    {
        "location": LOCATION,
        "extendedLocation": {"type": "EdgeZone", "name": PUBLIC_MEC_LOCATION},
        "sku": { "name": "Standard" },
        "public_ip_allocation_method": "Static",
        "public_ip_address_version" : "IPV4"
    }
)

ip_address_result = poller.result()

print(f"Provisioned public IP address {ip_address_result.name} with address {ip_address_result.ip_address}")

# Step 5: Provision the network interface client
poller = network_client.network_interfaces.begin_create_or_update(RESOURCE_GROUP_NAME,
    NIC_NAME, 
    {
        "location": LOCATION,
        "extendedLocation": {"type": "EdgeZone", "name": PUBLIC_MEC_LOCATION},
        "ip_configurations": [ {
            "name": IP_CONFIG_NAME,
            "subnet": { "id": subnet_result.id },
            "public_ip_address": {"id": ip_address_result.id }
        }]
    }
)

nic_result = poller.result()

print(f"Provisioned network interface client {nic_result.name}")

# Step 6: Provision the virtual machine

# Obtain the management object for virtual machines
compute_client = ComputeManagementClient(credential, subscription_id)

VM_NAME = "ExampleVM-edge"

print(f"Provisioning virtual machine {VM_NAME}; this operation might take a few minutes.")

# Provision the VM specifying only minimal arguments, which defaults to an Ubuntu 18.04 VM
# on a Standard DSv2-series with a public IP address and a default virtual network/subnet.

poller = compute_client.virtual_machines.begin_create_or_update(RESOURCE_GROUP_NAME, VM_NAME,
    {
        "location": LOCATION,
        "extendedLocation": {"type": "EdgeZone", "name": PUBLIC_MEC_LOCATION},
        "storage_profile": {
            "image_reference": {
                "publisher": 'Canonical',
                "offer": "UbuntuServer",
                "sku": "18.04-LTS",
                "version": "latest"
            }
        },
        "hardware_profile": {
            "vm_size": "Standard_DS2_v2"
        },
        "os_profile": {
            "computer_name": VM_NAME,
            "admin_username": USERNAME,
            "admin_password": PASSWORD
        },
        "network_profile": {
            "network_interfaces": [{
                "id": nic_result.id,
            }]
        }
    }
)

vm_result = poller.result()

print(f"Provisioned virtual machine {vm_result.name}")

Innan du kör skriptet fyller du i dessa variabler som används i steg 1 i skriptet:

Variabelnamn	beskrivning
PLATS	Azure-region som är associerad med den offentliga MEC-platsen i Azure
PUBLIC_MEC_LOCATION	Azure public MEC location identifier/edgezone ID
LÖSENORD	Lösenord som ska användas för att logga in på den virtuella datorn

Kommentar

Varje offentlig MEC-plats i Azure är associerad med en Azure-region. Baserat på den offentliga MEC-plats i Azure där resursen måste distribueras väljer du lämpligt regionvärde för den resursgrupp som ska skapas. Mer information finns i Viktiga begrepp för azure public MEC.

Kör skriptet i utvecklingsmiljön

Kör Python-skriptet som du kopierade från föregående avsnitt.
```
python provision_vm_edge.py
```

Vänta några minuter tills den virtuella datorn och stödresurserna har skapats.

Utdataresultatet i följande exempel anger att den virtuella datorn har skapats.

(.venv) C:\Users >python provision_vm_edge.py
Provisioning a virtual machine...some operations might take a minute or two.
Provisioned resource group PythonAzureExample-VM-rg in the <region> region
Provisioned virtual network python-example-vnet-edge with address prefixes ['10.1.0.0/16']
Provisioned virtual subnet python-example-subnet-edge with address prefix 10.1.0.0/24
Provisioned public IP address python-example-ip-edge with address <public ip>
Provisioned network interface client python-example-nic-edge
Provisioning virtual machine ExampleVM-edge; this operation might take a few minutes.
Provisioned virtual machine ExampleVM-edge

I utdata från fältet python-example-ip-edge noterar du din egen publicIpAddress. Använd den här adressen för att komma åt den virtuella datorn i nästa avsnitt.

Skapa en hoppserver i den associerade regionen

Om du vill använda SSH för att ansluta till den virtuella datorn i azure public MEC är den bästa metoden att distribuera en hoppruta i en Azure-region där resursgruppen distribuerades i föregående avsnitt.

Följ stegen i Använda Azure-biblioteken för att etablera en virtuell dator.
Observera din egen publicIpAddress i utdata från fältet python-example-ip på den virtuella jump server-datorn. Använd den här adressen för att komma åt den virtuella datorn i nästa avsnitt.

Få åtkomst till de virtuella datorerna

Använd SSH för att ansluta till den virtuella jump box-dator som du distribuerade i regionen med dess IP-adress som du antecknade tidigare.
```
ssh  azureuser@<python-example-ip>
```
Från hopprutan använder du SSH för att ansluta till den virtuella dator som du skapade i azure public MEC med dess IP-adress som du antecknade tidigare.
```
ssh azureuser@<python-example-ip-edge>
```
Se till att Azure-nätverkssäkerhetsgrupperna tillåter port 22-åtkomst till de virtuella datorer som du skapar.

Rensa resurser

I den här självstudien skapade du en virtuell dator i azure public MEC med hjälp av Python SDK. Om du inte förväntar dig att behöva dessa resurser i framtiden använder du kommandot az group delete för att ta bort resursgruppen, skalningsuppsättningen och alla relaterade resurser. Med hjälp av parametern --yes tas resurserna bort utan en bekräftelsefråga.

az group delete --name PythonAzureExample-VM-rg --yes

Nästa steg

Om du vill ha frågor om azure public MEC kontaktar du produktteamet:

Azures offentliga MEC-produktteam

Dela via