Linux számítási csomópontok kiépítése Batch-készletekben

  • Cikk

A Azure Batch használatával párhuzamos számítási feladatokat futtathat Linux és Windows rendszerű virtuális gépeken is. Ez a cikk bemutatja, hogyan hozhat létre Linux számítási csomópontkészleteket a Batch szolgáltatásban a Batch Python - és Batch .NET-ügyfélkódtárak használatával.

Virtuális gép konfigurációja

Amikor számítási csomópontkészletet hoz létre a Batchben, két lehetőség közül választhatja ki a csomópont méretét és operációs rendszerét: Cloud Services Konfiguráció és Virtuálisgép-konfiguráció. A virtuálisgép-konfigurációs készletek Azure-beli virtuális gépekből állnak, amelyek Linux vagy Windows rendszerképekből hozhatók létre. Amikor virtuálisgép-konfigurációval hoz létre készletet, meg kell adnia egy elérhető számítási csomópontméretet, a csomópontokra telepíteni kívánt virtuálisgép-rendszerképre mutató hivatkozást, valamint a Batch-csomópont ügynök termékváltozatát (egy olyan programot, amely minden csomóponton fut, és interfészt biztosít a csomópont és a Batch szolgáltatás között).

Virtuális gép rendszerképének referenciája

A Batch szolgáltatás virtuálisgép-méretezési csoportokkal biztosítja a számítási csomópontokat a virtuális gép konfigurációjában. Megadhat egy rendszerképet a Azure Marketplace, vagy az Azure Compute Gallery használatával készíthet elő egyéni rendszerképet.

Virtuálisgép-rendszerkép-referencia létrehozásakor a következő tulajdonságokat kell megadnia:

Képhivatkozás tulajdonság Példa
Publisher Canonical
Ajánlat UbuntuServer
SKU 20.04-LTS
Verzió legújabb

Tipp

Ezekről a tulajdonságokról és a Marketplace-rendszerképek megadásáról további információt a Linux rendszerű virtuálisgép-rendszerképek keresése az Azure CLI-vel Azure Marketplace című témakörben talál. Vegye figyelembe, hogy egyes Marketplace-rendszerképek jelenleg nem kompatibilisek a Batch szolgáltatással.

Virtuálisgép-rendszerképek listája

Nem minden Marketplace-rendszerkép kompatibilis a jelenleg elérhető Batch-csomópontügynökökkel. A Batch szolgáltatáshoz és a hozzájuk tartozó csomópontügynök termékváltozataihoz támogatott Marketplace virtuálisgép-rendszerképek listázásához használja a list_supported_images (Python), a ListSupportedImages (Batch .NET) vagy a megfelelő API-t egy másik nyelvű SDK-ban.

Csomóponti ügynök termékváltozata

A Batch-csomópontügynök egy olyan program, amely a készlet minden csomópontján fut, és biztosítja a parancs- és vezérlési felületet a csomópont és a Batch szolgáltatás között. A csomópontügynöknek különböző implementációi vannak, más néven termékváltozatok a különböző operációs rendszerekhez. A virtuálisgép-konfiguráció létrehozásakor először meg kell adnia a virtuálisgép-rendszerkép referenciáját, majd meg kell adnia a lemezképre telepíteni kívánt csomópontügynököt. Az egyes csomópontügynök-termékváltozatok általában több virtuálisgép-lemezképpel kompatibilisek. A támogatott csomópontügynök termékváltozatainak és a virtuálisgép-rendszerképek kompatibilitásának megtekintéséhez használhatja a Azure Batch CLI-parancsot:

az batch pool supported-images list

További információ: Fiók – Támogatott rendszerképek listázása – REST API (Azure Batch szolgáltatás) | Microsoft Docs.

Linux-készlet létrehozása: Batch Python

Az alábbi kódrészlet bemutatja, hogyan hozhat létre Ubuntu Server számítási csomópontok készletét a Pythonhoz készült Microsoft Azure Batch Ügyfélkódtár használatával. A Batch Python-modullal kapcsolatos további részletekért tekintse meg a referenciadokumentációt.

Ez a kódrészlet explicit módon létrehoz egy ImageReference függvényt, és megadja annak minden tulajdonságát (közzétevő, ajánlat, termékváltozat, verzió). Az éles kódban azonban azt javasoljuk, hogy a list_supported_images metódust használja a rendelkezésre álló lemezkép- és csomópontügynök-termékváltozat-kombinációk közül futásidőben történő kiválasztásához.

# Import the required modules from the
# Azure Batch Client Library for Python
import azure.batch.batch_service_client as batch
import azure.batch.batch_auth as batchauth
import azure.batch.models as batchmodels

# Specify Batch account credentials
account = "<batch-account-name>"
key = "<batch-account-key>"
batch_url = "<batch-account-url>"

# Pool settings
pool_id = "LinuxNodesSamplePoolPython"
vm_size = "STANDARD_D2_V3"
node_count = 1

# Initialize the Batch client
creds = batchauth.SharedKeyCredentials(account, key)
config = batch.BatchServiceClientConfiguration(creds, batch_url)
client = batch.BatchServiceClient(creds, batch_url)

# Create the unbound pool
new_pool = batchmodels.PoolAddParameter(id=pool_id, vm_size=vm_size)
new_pool.target_dedicated = node_count

# Configure the start task for the pool
start_task = batchmodels.StartTask()
start_task.run_elevated = True
start_task.command_line = "printenv AZ_BATCH_NODE_STARTUP_DIR"
new_pool.start_task = start_task

# Create an ImageReference which specifies the Marketplace
# virtual machine image to install on the nodes
ir = batchmodels.ImageReference(
    publisher="Canonical",
    offer="UbuntuServer",
    sku="20.04-LTS",
    version="latest")

# Create the VirtualMachineConfiguration, specifying
# the VM image reference and the Batch node agent
# to install on the node
vmc = batchmodels.VirtualMachineConfiguration(
    image_reference=ir,
    node_agent_sku_id="batch.node.ubuntu 20.04")

# Assign the virtual machine configuration to the pool
new_pool.virtual_machine_configuration = vmc

# Create pool in the Batch service
client.pool.add(new_pool)

Ahogy korábban említettük, javasoljuk, hogy a list_supported_images metódussal dinamikusan válasszon a jelenleg támogatott csomópontügynök/Marketplace rendszerkép kombinációi közül (ahelyett, hogy explicit módon hoznánk létre az ImageReference-t ). Az alábbi Python-kódrészlet bemutatja, hogyan használhatja ezt a módszert.

# Get the list of supported images from the Batch service
images = client.account.list_supported_images()

# Obtain the desired image reference
image = None
for img in images:
  if (img.image_reference.publisher.lower() == "canonical" and
        img.image_reference.offer.lower() == "ubuntuserver" and
        img.image_reference.sku.lower() == "20.04-lts"):
    image = img
    break

if image is None:
  raise RuntimeError('invalid image reference for desired configuration')

# Create the VirtualMachineConfiguration, specifying the VM image
# reference and the Batch node agent to be installed on the node
vmc = batchmodels.VirtualMachineConfiguration(
    image_reference=image.image_reference,
    node_agent_sku_id=image.node_agent_sku_id)

Linux-készlet létrehozása: Batch .NET

Az alábbi kódrészlet bemutatja, hogyan hozhat létre Ubuntu Server számítási csomópontok készletét a Batch .NET ügyfélkódtár használatával. A Batch .NET-tel kapcsolatos további részletekért tekintse meg a referenciadokumentációt.

Az alábbi kódrészlet a PoolOperations.ListSupportedImages metódust használja a jelenleg támogatott Marketplace-rendszerkép- és csomópontügynök-termékváltozat-kombinációk listájából való választáshoz. Ez a módszer azért ajánlott, mert a támogatott kombinációk listája időről időre változhat. A leggyakrabban támogatott kombinációkat adnak hozzá.

// Pool settings
const string poolId = "LinuxNodesSamplePoolDotNet";
const string vmSize = "STANDARD_D2_V3";
const int nodeCount = 1;

// Obtain a collection of all available node agent SKUs.
// This allows us to select from a list of supported
// VM image/node agent combinations.
List<ImageInformation> images =
    batchClient.PoolOperations.ListSupportedImages().ToList();

// Find the appropriate image information
ImageInformation image = null;
foreach (var img in images)
{
    if (img.ImageReference.Publisher == "Canonical" &&
        img.ImageReference.Offer == "UbuntuServer" &&
        img.ImageReference.Sku == "20.04-LTS")
    {
        image = img;
        break;
    }
}

// Create the VirtualMachineConfiguration for use when actually
// creating the pool
VirtualMachineConfiguration virtualMachineConfiguration =
    new VirtualMachineConfiguration(image.ImageReference, image.NodeAgentSkuId);

// Create the unbound pool object using the VirtualMachineConfiguration
// created above
CloudPool pool = batchClient.PoolOperations.CreatePool(
    poolId: poolId,
    virtualMachineSize: vmSize,
    virtualMachineConfiguration: virtualMachineConfiguration,
    targetDedicatedComputeNodes: nodeCount);

// Commit the pool to the Batch service
await pool.CommitAsync();

Bár az előző kódrészlet a PoolOperations.istSupportedImages metódust használja a támogatott rendszerkép- és csomópontügynök-termékváltozat-kombinációk dinamikus listázásához és kiválasztásához (ajánlott), az ImageReference-t explicit módon is konfigurálhatja:

ImageReference imageReference = new ImageReference(
    publisher: "Canonical",
    offer: "UbuntuServer",
    sku: "20.04-LTS",
    version: "latest");

Csatlakozás Linux-csomópontokhoz SSH használatával

A fejlesztés során vagy a hibaelhárítás során előfordulhat, hogy be kell jelentkeznie a készletben lévő csomópontokra. A Windows számítási csomópontjaitól eltérően a Távoli asztali protokoll (RDP) nem használható Linux-csomópontokhoz való csatlakozáshoz. Ehelyett a Batch szolgáltatás minden csomóponton engedélyezi az SSH-hozzáférést a távoli kapcsolathoz.

A következő Python-kódrészlet létrehoz egy felhasználót a készlet minden csomópontján, ami a távoli kapcsolathoz szükséges. Ezután kinyomtatja a biztonságos rendszerhéj (SSH) kapcsolati adatait az egyes csomópontokhoz.

import datetime
import getpass
import azure.batch.batch_service_client as batch
import azure.batch.batch_auth as batchauth
import azure.batch.models as batchmodels

# Specify your own account credentials
batch_account_name = ''
batch_account_key = ''
batch_account_url = ''

# Specify the ID of an existing pool containing Linux nodes
# currently in the 'idle' state
pool_id = ''

# Specify the username and prompt for a password
username = 'linuxuser'
password = getpass.getpass()

# Create a BatchClient
credentials = batchauth.SharedKeyCredentials(
    batch_account_name,
    batch_account_key
)
batch_client = batch.BatchServiceClient(
    credentials,
    base_url=batch_account_url
)

# Create the user that will be added to each node in the pool
user = batchmodels.ComputeNodeUser(username)
user.password = password
user.is_admin = True
user.expiry_time = \
    (datetime.datetime.today() + datetime.timedelta(days=30)).isoformat()

# Get the list of nodes in the pool
nodes = batch_client.compute_node.list(pool_id)

# Add the user to each node in the pool and print
# the connection information for the node
for node in nodes:
    # Add the user to the node
    batch_client.compute_node.add_user(pool_id, node.id, user)

    # Obtain SSH login information for the node
    login = batch_client.compute_node.get_remote_login_settings(pool_id,
                                                                node.id)

    # Print the connection info for the node
    print("{0} | {1} | {2} | {3}".format(node.id,
                                         node.state,
                                         login.remote_login_ip_address,
                                         login.remote_login_port))

A kód kimenete az alábbi példához hasonló lesz. Ebben az esetben a készlet négy Linux-csomópontot tartalmaz.

Password:
tvm-1219235766_1-20160414t192511z | ComputeNodeState.idle | 13.91.7.57 | 50000
tvm-1219235766_2-20160414t192511z | ComputeNodeState.idle | 13.91.7.57 | 50003
tvm-1219235766_3-20160414t192511z | ComputeNodeState.idle | 13.91.7.57 | 50002
tvm-1219235766_4-20160414t192511z | ComputeNodeState.idle | 13.91.7.57 | 50001

Jelszó helyett megadhat egy nyilvános SSH-kulcsot, amikor felhasználót hoz létre egy csomóponton.

A Python SDK-ban használja a ComputeNodeUser ssh_public_key paraméterét.

A .NET-ben használja a ComputeNodeUser.SshPublicKey tulajdonságot.

Díjszabás

Azure Batch az Azure Cloud Services és az Azure Virtual Machines technológiára épül. Maga a Batch szolgáltatás díjmentesen érhető el, ami azt jelenti, hogy csak a Batch-megoldások által felhasznált számítási erőforrásokért (és a kapcsolódó költségekért) kell fizetnie. Ha a Virtuális gép konfigurációja lehetőséget választja, a díjakat a Virtual Machines díjszabási struktúrája alapján számítjuk fel.

Ha alkalmazáscsomagokkal helyez üzembe alkalmazásokat a Batch-csomópontokon, az alkalmazáscsomagok által felhasznált Azure Storage-erőforrásokért is fizetnie kell.

Következő lépések