Tárolókhoz kapcsolódó számítási feladatok futtatása az Azure Batch használatával

Az Azure Batch segítségével nagy mennyiségű kötegelt számítási feladatot futtathat és skálázhat az Azure-ban. A Batch-feladatok közvetlenül futtathatók a Batch-készletben lévő virtuális gépeken (csomópontokon), de egy Batch-készletet beállíthat úgy is, hogy Docker-kompatibilis tárolókban futtassa a feladatokat a csomópontokon. Ez a cikk bemutatja, hogyan hozhat létre olyan számításicsomópont-készletet, amely támogatja a tárolófeladatok futtatását, majd azt követően miként futtathat tárolófeladatokat a készleten.

Az itt látható példakódok a Batch .NET és a Python SDK-kat használják. Más Batch SDK-k és -eszközök, például az Azure Portal használatával is létrehozhat tárolóalapú Batch-készleteket, és tárolófeladatokat futtathat.

Miért érdemes tárolókat használni?

A tárolók megkönnyítik a Batch-feladatok futtatását anélkül, hogy egy környezetet és függőséget kellene kezelni az alkalmazások futtatásához. A tárolók egyszerű, hordozható, önellátó egységekként helyeznek üzembe alkalmazásokat, amelyek több különböző környezetben is futtathatók. Létrehozhat és tesztelhet például egy tárolót helyileg, majd feltöltheti a tárolórendszerképet egy Azure-beli vagy más adatbázisba. A tárolótelepítési modell biztosítja, hogy az alkalmazás futtatókörnyezete mindig megfelelően legyen telepítve és konfigurálva, bárhol is üzemelteti az alkalmazást. A Batch tárolóalapú tevékenységei a nem tárolófeladatok funkcióit is kihasználhatják, beleértve az alkalmazáscsomagokat, valamint az erőforrásfájlok és kimeneti fájlok kezelését.

Előfeltételek

Ismernie kell a tároló fogalmait, valamint a Batch-készlet és -feladatok létrehozását.

• SDK-verziók: A Batch SDK-k a következő verziókban támogatják a tárolólemezképeket:

  • Batch REST API 2017-09-01.6.0-s verzió
  • Batch .NET SDK 8.0.0-s verzió
  • Batch Python SDK 4.0-s verzió
  • Batch Java SDK 3.0-s verzió
  • Batch Node.js SDK 3.0-s verziója

• Fiókok: Az Azure-előfizetésben létre kell hoznia egy Batch-fiókot és opcionálisan egy Azure Storage-fiókot.

• Támogatott virtuálisgép-rendszerkép: A tárolók csak a virtuálisgép-konfigurációval létrehozott készletekben támogatott (a következő szakaszban felsorolt) rendszerképből támogatottak. Ha egyéni rendszerképet ad meg, tekintse meg a következő szakaszban található szempontokat, valamint a Felügyelt rendszerkép használata egyéni képkészlet létrehozásához című témakör követelményeit.

Jelenleg a containerConfiguration Type tulajdonságot át kell adni, a támogatott értékek pedig a következők: ContainerType.DockerCompatible és ContainerType.CriCompatible.

Tartsa szem előtt a következő korlátozásokat:

• A Batch csak Linux-készleteken futó tárolók esetén nyújt távoli közvetlen memóriahozzáférést (RDMA).
• Windows-tárolók számítási feladataihoz többmagos virtuálisgép-méretet kell választania a készlethez.

Támogatott virtuálisgép-rendszerképek

A következő támogatott Windows- vagy Linux-rendszerképek egyikével hozzon létre virtuálisgép-számítási csomópontokat tárolóterhelésekhez. A Batchtel kompatibilis Marketplace-rendszerképekről további információt a virtuálisgép-rendszerképek listájában talál.

Windows-támogatás

A Batch támogatja a tárolótámogatási megjelöléssel rendelkező Windows Server-rendszerképeket. A Batchben az összes támogatott rendszerképet listázó API egy képességet DockerCompatible jelöl, ha a rendszerkép támogatja a Docker-tárolókat. A Batch lehetővé teszi, de nem támogatja közvetlenül a Mirantis által közzétett képeket a következő funkcióval: DockerCompatible. Ezek a rendszerképek csak felhasználói előfizetési készlet kiosztási módú Batch-fiókban helyezhetők üzembe.

Egyéni rendszerképet is létrehozhat a tárolófunkciók windowsos engedélyezéséhez.

Linux-támogatás

Linux-tárolók számítási feladatai esetében a Batch jelenleg az Azure Marketplace-en közzétett alábbi Linux-lemezképeket támogatja egyéni rendszerképek nélkül.

• Kiadó: microsoft-dsvm
  • Ajánlat: ubuntu-hpc
• Kiadó: almalinux
  • Ajánlat: 8-hpc-gen1
  • Ajánlat: 8-hpc-gen2

Alternatív képbeállítások

A tároló számítási feladatait jelenleg más rendszerképek is támogatják microsoft-azure-batch :

• Kiadó: microsoft-azure-batch
  • Ajánlat: ubuntu-server-container
  • Ajánlat: ubuntu-server-container-rdma (Kizárólag infiniband virtuálisgép-termékváltozatokon használható)

Jegyzetek

A fenti képek Docker-adatgyökere különböző helyeken található:

• A HPC-rendszerkép vagy microsoft-dsvm (Ajánlat: ubuntu-hpcstb.) esetében a Docker-adatgyökér nem változik a Docker alapértelmezett értékétől, amely Linuxon a /var/lib/docker , a Windowson pedig a C:\ProgramData\Docker . Ezek a mappák az operációsrendszer-lemezen találhatók.

Nem Batch-alapú közzétett rendszerképek esetén az operációsrendszer-lemezen fennáll a veszélye annak, hogy a tárolólemezképek letöltésekor gyorsan megtelnek.

Lehetséges megoldások az ügyfelek számára

Ha készletet hoz létre a BatchExplorerben, módosítsa a docker-adatgyökerét egy kezdőfeladatban. Íme egy példa a Feladat indítása parancsra:

1)  sudo systemctl stop docker
2)  sudo vi /lib/systemd/system/docker.service
    +++
    FROM:
    ExecStart=/usr/bin/docker daemon -H fd://
    TO:
    ExecStart=/usr/bin/docker daemon -g /new/path/docker -H fd://
    +++
3)  sudo systemctl daemon-reload
4)  sudo systemctl start docker

Ezek a rendszerképek csak az Azure Batch-készletekben használhatók, és a Docker-tárolók végrehajtására vannak összhangban. Ezek a funkciók:

• Előre telepített Docker-kompatibilis Moby-tároló futtatókörnyezet.
• Előre telepített NVIDIA GPU-illesztőprogramok és NVIDIA tároló-futtatókörnyezet az Azure N sorozatú virtuális gépek üzembe helyezésének egyszerűsítése érdekében.
• A virtuálisgép-rendszerképek utótagja -rdma előre konfigurálva van az InfiniBand RDMA virtuálisgép-méretek támogatásával. Ezeket a virtuálisgép-lemezképeket nem szabad olyan virtuálisgép-méretekkel használni, amelyek nem rendelkeznek InfiniBand-támogatással.

A Batch-tárolókhoz kompatibilis egyéni rendszerképeket is létrehozhat a Batchtel kompatibilis Linux-disztribúciók egyikén. Ha egyéni rendszerképen szeretné támogatni a Dockert, telepítsen egy megfelelő Docker-kompatibilis futtatókörnyezetet, például a Docker vagy a Mirantis Container Runtime verzióját. Csak egy Docker-CLI-kompatibilis eszköz telepítése nem elegendő; Docker Engine-kompatibilis futtatókörnyezetre van szükség.

További szempontok az egyéni Linux-rendszerképek használatához:

• Ha egyéni rendszerkép használata esetén szeretné kihasználni az Azure N sorozatú méretek GPU-teljesítményének előnyeit, telepítse előre az NVIDIA-illesztőprogramokat. Emellett telepítenie kell az NVIDIA GPU-khoz készült Docker Engine Segédprogramot, az NVIDIA Dockert.
• Az Azure RDMA-hálózat eléréséhez használjon RDMA-kompatibilis virtuálisgép-méretet. A szükséges RDMA-illesztőprogramok telepítve vannak a CentOS HPC és a Batch által támogatott Ubuntu rendszerképekben. Az MPI-számítási feladatok futtatásához további konfigurációra lehet szükség. Lásd: RDMA- vagy GPU-példányok használata a Batch-készletben.

Batch-készlet tárolókonfigurációja

Ha engedélyezni szeretné a Batch-készlet számára a tárolóterhelések futtatását, meg kell adnia a ContainerConfiguration beállításait a készlet VirtualMachineConfiguration objektumában. Ez a cikk a Batch .NET API-referenciára mutató hivatkozásokat tartalmaz. A megfelelő beállítások a Batch Python API-ban találhatók.

A tárolóbarát készletet előre beszúrt tárolórendszerképekkel vagy anélkül is létrehozhatja, ahogyan az alábbi példákban is látható. A lekéréses (vagy előzetes) folyamat lehetővé teszi a tárolólemezképek előzetes betöltését a Docker Hubról vagy egy másik internetes tárolóregisztrációs adatbázisból. A legjobb teljesítmény érdekében használjon azure-tárolóregisztrációs adatbázist ugyanabban a régióban, mint a Batch-fiók.

A tárolólemezképek előkezelésének előnye, hogy amikor a feladatok először futnak, nem kell megvárniuk a tárolórendszerkép letöltését. A tárolókonfiguráció a készlet létrehozásakor lekéri a tárolórendszerképeket a virtuális gépekre. A készleten futó feladatok ezután hivatkozhatnak a tárolólemezképek listájára és a tároló futtatási beállításaira.

Készlet előre bevésett tárolólemezképek nélkül

Tárolóbarát készlet előzetes tárolólemezképek nélküli konfigurálásához definiáljon ContainerConfiguration és VirtualMachineConfiguration objektumokat az alábbi példákban látható módon. Ezek a példák az Ubuntu Server for Azure Batch tárolókészletek rendszerképét használják a Marketplace-ről.

Megjegyzés: A példában használt Ubuntu-kiszolgáló verziója illusztrációs célra szolgál. Nyugodtan módosítsa a node_agent_sku_id a használt verzióra.

image_ref_to_use = batch.models.ImageReference(
    publisher='microsoft-dsvm',
    offer='ubuntu-hpc',
    sku='2204',
    version='latest')

"""
Specify container configuration. This is required even though there are no prefetched images.
"""

container_conf = batch.models.ContainerConfiguration()

new_pool = batch.models.PoolAddParameter(
    id=pool_id,
    virtual_machine_configuration=batch.models.VirtualMachineConfiguration(
        image_reference=image_ref_to_use,
        container_configuration=container_conf,
        node_agent_sku_id='batch.node.ubuntu 22.04'),
    vm_size='STANDARD_D2S_V3',
    target_dedicated_nodes=1)
...

ImageReference imageReference = new ImageReference(
    publisher: "microsoft-dsvm",
    offer: "ubuntu-hpc",
    sku: "2204",
    version: "latest");

// Specify container configuration. This is required even though there are no prefetched images.
ContainerConfiguration containerConfig = new ContainerConfiguration();

// VM configuration
VirtualMachineConfiguration virtualMachineConfiguration = new VirtualMachineConfiguration(
    imageReference: imageReference,
    nodeAgentSkuId: "batch.node.ubuntu 22.04");
virtualMachineConfiguration.ContainerConfiguration = containerConfig;

// Create pool
CloudPool pool = batchClient.PoolOperations.CreatePool(
    poolId: poolId,
    targetDedicatedComputeNodes: 1,
    virtualMachineSize: "STANDARD_D2S_V3",
    virtualMachineConfiguration: virtualMachineConfiguration);

Előzetes lemezképek tárolókonfigurációhoz

A tárolólemezképek készleten való előkezeléséhez adja hozzá a tárolólemezképek listáját (container_image_names Pythonban) a ContainerConfiguration.

Az alábbi egyszerű Python-példa bemutatja, hogyan lehet elővenni egy szabványos Ubuntu tárolórendszerképet a Docker Hubról.

image_ref_to_use = batch.models.ImageReference(
    publisher='microsoft-dsvm',
    offer='ubuntu-hpc',
    sku='2204',
    version='latest')

"""
Specify container configuration, fetching the official Ubuntu container image from Docker Hub.
"""

container_conf = batch.models.ContainerConfiguration(
    container_image_names=['ubuntu'])

new_pool = batch.models.PoolAddParameter(
    id=pool_id,
    virtual_machine_configuration=batch.models.VirtualMachineConfiguration(
        image_reference=image_ref_to_use,
        container_configuration=container_conf,
        node_agent_sku_id='batch.node.ubuntu 22.04'),
    vm_size='STANDARD_D2S_V3',
    target_dedicated_nodes=1)
...

Az alábbi C#-példa feltételezi, hogy egy TensorFlow-rendszerképet szeretne elővenni a Docker Hubról. Ez a példa egy indítási feladatot tartalmaz, amely a készletcsomópontok virtuálisgép-gazdagépén fut. Futtathat például egy indítási feladatot a gazdagépen a tárolókból elérhető fájlkiszolgáló csatlakoztatásához.

ImageReference imageReference = new ImageReference(
    publisher: "microsoft-dsvm",
    offer: "ubuntu-hpc",
    sku: "2204",
    version: "latest");

ContainerRegistry containerRegistry = new ContainerRegistry(
    registryServer: "https://hub.docker.com",
    identityReference: new ComputeNodeIdentityReference() { ResourceId = "/subscriptions/SUB/resourceGroups/RG/providers/Microsoft.ManagedIdentity/userAssignedIdentities/identity-name" }
);

// Specify container configuration, prefetching Docker images
ContainerConfiguration containerConfig = new ContainerConfiguration();
containerConfig.ContainerImageNames = new List<string> { "tensorflow/tensorflow:latest-gpu" };
containerConfig.ContainerRegistries = new List<ContainerRegistry> { containerRegistry };

// VM configuration
VirtualMachineConfiguration virtualMachineConfiguration = new VirtualMachineConfiguration(
    imageReference: imageReference,
    nodeAgentSkuId: "batch.node.ubuntu 22.04");
virtualMachineConfiguration.ContainerConfiguration = containerConfig;

// Set a native host command line start task
StartTask startTaskContainer = new StartTask( commandLine: "<native-host-command-line>" );

// Create pool
CloudPool pool = batchClient.PoolOperations.CreatePool(
    poolId: poolId,
    virtualMachineSize: "Standard_NC6S_V3",
    virtualMachineConfiguration: virtualMachineConfiguration);

// Start the task in the pool
pool.StartTask = startTaskContainer;
...

Rendszerképek előkezelése privát tárolóregisztrációs adatbázisból

A tárolórendszerképeket úgy is előveheti, hogy egy privát tárolóregisztrációs kiszolgálót hitelesít. Az alábbi példákban az ContainerConfiguration és VirtualMachineConfiguration az objektumok elővesznek egy privát TensorFlow-rendszerképet egy privát Azure-tárolóregisztrációs adatbázisból. A képhivatkozás ugyanaz, mint az előző példában.

image_ref_to_use = batch.models.ImageReference(
    publisher='microsoft-dsvm',
    offer='ubuntu-hpc',
    sku='2204',
    version='latest')

# Specify a container registry
subscription_id = "yyyy-yyy-yyy-yyy-yyy"
resource_group_name = "TestRG"
user_assigned_identity_name = "testUMI"
resource_id = f"/subscriptions/{subscription_id}/resourceGroups/{resource_group_name}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{user_assigned_identity_name}"

container_registry = batch.models.ContainerRegistry(
        registry_server="myRegistry.azurecr.io",
        identity_reference = ComputeNodeIdentityReference(resource_id = resource_id))

# Create container configuration, prefetching Docker images from the container registry
container_conf = batch.models.ContainerConfiguration(
        container_image_names = ["myRegistry.azurecr.io/samples/myImage"],
        container_registries =[container_registry])

new_pool = batch.models.PoolAddParameter(
            id="myPool",
            virtual_machine_configuration=batch.models.VirtualMachineConfiguration(
                image_reference=image_ref_to_use,
                container_configuration=container_conf,
                node_agent_sku_id='batch.node.ubuntu 22.04'),
            vm_size='STANDARD_D2S_V3',
            target_dedicated_nodes=1)

// Specify a container registry
ContainerRegistry containerRegistry = new ContainerRegistry(
    registryServer: "myContainerRegistry.azurecr.io",
    identityReference: new ComputeNodeIdentityReference() { ResourceId = "/subscriptions/SUB/resourceGroups/RG/providers/Microsoft.ManagedIdentity/userAssignedIdentities/identity-name" }
);

// Create container configuration, prefetching Docker images from the container registry
ContainerConfiguration containerConfig = new ContainerConfiguration();
containerConfig.ContainerImageNames = new List<string> {
        "myContainerRegistry.azurecr.io/tensorflow/tensorflow:latest-gpu" };
containerConfig.ContainerRegistries = new List<ContainerRegistry> { containerRegistry } );

// VM configuration
VirtualMachineConfiguration virtualMachineConfiguration = new VirtualMachineConfiguration(
    imageReference: imageReference,
    nodeAgentSkuId: "batch.node.ubuntu 22.04");
virtualMachineConfiguration.ContainerConfiguration = containerConfig;

// Create pool
CloudPool pool = batchClient.PoolOperations.CreatePool(
    poolId: poolId,
    targetDedicatedComputeNodes: 2,
    virtualMachineSize: "Standard_NC6S_V3",
    virtualMachineConfiguration: virtualMachineConfiguration);
...

Felügyelt identitás támogatása az ACR-hez

Az Azure Container Registryben tárolt tárolók elérésekor egy felügyelt identitás használható a szolgáltatással való hitelesítéshez. Felügyelt identitás használatához először győződjön meg arról, hogy az identitás hozzá lett rendelve a készlethez , és hogy az identitáshoz hozzá van rendelve az AcrPull elérni kívánt tárolóregisztrációs adatbázis szerepköre. Ezután utasítsa a Batchet, hogy melyik identitást használja az ACR-hitelesítés során.

ContainerRegistry containerRegistry = new ContainerRegistry(
    registryServer: "myContainerRegistry.azurecr.io",
    identityReference: new ComputeNodeIdentityReference() { ResourceId = "/subscriptions/SUB/resourceGroups/RG/providers/Microsoft.ManagedIdentity/userAssignedIdentities/identity-name" }
);

// Create container configuration, prefetching Docker images from the container registry
ContainerConfiguration containerConfig = new ContainerConfiguration();
containerConfig.ContainerImageNames = new List<string> {
        "myContainerRegistry.azurecr.io/tensorflow/tensorflow:latest-gpu" };
containerConfig.ContainerRegistries = new List<ContainerRegistry> { containerRegistry } );

// VM configuration
VirtualMachineConfiguration virtualMachineConfiguration = new VirtualMachineConfiguration(
    imageReference: imageReference,
    nodeAgentSkuId: "batch.node.ubuntu 22.04");
virtualMachineConfiguration.ContainerConfiguration = containerConfig;

// Create pool
CloudPool pool = batchClient.PoolOperations.CreatePool(
    poolId: poolId,
    targetDedicatedComputeNodes: 2,
    virtualMachineSize: "Standard_NC6S_V3",
    virtualMachineConfiguration: virtualMachineConfiguration);
...

A feladat tárolóbeállításai

Tárolófeladat tárolóalapú készleten való futtatásához adja meg a tárolóspecifikus beállításokat. A beállítások közé tartozik a használni kívánt rendszerkép, a beállításjegyzék és a tárolófuttatási beállítások.

• ContainerSettings A feladatosztályok tulajdonságával konfigurálhatja a tárolóspecifikus beállításokat. Ezeket a beállításokat a TaskContainerSettings osztály határozza meg. A --rm tárolóbeállítás nem igényel másik --runtime lehetőséget, mivel a Batch gondoskodik róla.

• Ha a feladatokat tárolólemezképeken futtatja, a felhőbeli tevékenységhez és a feladatkezelői feladathoz tárolóbeállításokra van szükség. A kezdési, a feladat-előkészítési és a feladat-kiadási tevékenységhez azonban nincs szükség tárolóbeállításokra (azaz tárolókörnyezetben vagy közvetlenül a csomóponton futtathatók).

• Linux esetén a Batch leképezi a felhasználó/csoport engedélyét a tárolóra. Ha a tároló bármely mappájához rendszergazdai engedély szükséges, előfordulhat, hogy a feladatot készlethatókörként kell futtatnia rendszergazdai jogosultságszinttel. Ez biztosítja, hogy a Batch gyökérként futtassa a feladatot a tárolókörnyezetben. Ellenkező esetben előfordulhat, hogy egy nem rendszergazdai felhasználó nem fér hozzá ezekhez a mappákhoz.

• GPU-kompatibilis hardverrel rendelkező tárolókészletek esetén a Batch automatikusan engedélyezi a GPU-t a tárolófeladatokhoz, ezért ne foglalja bele az –gpus argumentumot.

Tárolótevékenység parancssora

Tárolófeladat futtatásakor a Batch automatikusan a docker create paranccsal hoz létre egy tárolót a feladatban megadott rendszerkép használatával. A Batch ezután szabályozza a feladat végrehajtását a tárolóban.

A nem tárolóalapú Batch-tevékenységekhez hasonlóan egy tárolófeladathoz is beállíthat egy parancssort. Mivel a Batch automatikusan létrehozza a tárolót, a parancssor csak a tárolóban futó parancsokat vagy parancsokat adja meg.

A Batch a Docker-tárolófeladatokra az alábbi alapértelmezett viselkedéseket alkalmazza:

• A Batch parancsmagként futtatja a tárolót a megadott feladatparancsvonallal.
• A Batch nem zavarja a tárolólemezkép megadott ENTRYPOINT-pontját .
• A Batch felülbírálja a WORKDIR-t a Batch tevékenység munkakönyvtárával.

Győződjön meg arról, hogy áttekinti a Docker dokumentációját az ENTRYPOINT és a CMD között, hogy megértse azokat az interakciós hatásokat, amelyek akkor fordulhatnak elő, ha a tárolólemezképek rendelkeznek egy adott ENTRYPOINT-tal, és meg kell adnia egy feladatparancssort is.

Ha felül szeretné bírálni a ENTRYPOINT tárolórendszerképet, megadhatja az --entrypoint <args> argumentumot containerRunOptionként. Tekintse meg az opcionális ContainerRunOptions argumentumokat , amelyeket a Batch által a docker create tároló létrehozásához és futtatásához használt parancsnak adhat meg. Ha például egy munkakönyvtárat szeretne beállítani a tárolóhoz, állítsa be a --workdir <directory> beállítást.

Az alábbiakban néhány példa látható a tárolórendszerképre és a Batch tárolóbeállításaira vagy a feladat parancssoraira, valamint azok hatására:

• A container image ENTRYPOINT nincs megadva, a Batch-feladat parancssora pedig "/bin/sh -c python myscript.py".
  • A Batch a megadott Batch-feladat parancssorával hozza létre a tárolót, és a Batch tevékenység munkakönyvtárában futtatja. Ez meghiúsulhat, ha a "myscript.py" nincs a Batch tevékenység munkakönyvtárában.
  • Ha a feladat parancssora "/bin/sh -c python /path/to/script/myscript.py" néven van megadva, akkor ez a feladat akkor is megfelelően működik, ha a batch tevékenység munkakönyvtáraként beállított munkakönyvtárban a szkript összes függősége teljesül.
• A tárolórendszerkép ENTRYPOINTja "./myscript.sh" néven van megadva, a Batch-feladat parancssora pedig üres.
  • A Batch létrehozza a ENTRYPOINT-alapú tárolót, és a Batch tevékenység munkakönyvtárában futtatja. Ez a feladat meghiúsulhat, ha a tároló lemezképe, a WORKDIR nem ugyanaz, mint a Batch tevékenység munkakönyvtára, amely különböző tényezőktől függ, például az operációs rendszertől, a feladatazonosítótól, a tevékenységazonosítótól stb.
  • Ha a "--workdir /path/to/script" tárolóRunOptionként lett megadva, akkor ez a feladat megfelelően működik, ha a szkript összes függősége teljesül.
• A container image ENTRYPOINT nincs megadva, a Batch-feladat parancssora "./myscript.sh", a WORKDIR pedig felülbírált a ContainerRunOptionsban "--workdir /path/to/script" néven.
  • A Batch létrehozza a "/path/to/script" munkakönyvtárral rendelkező tárolót, és végrehajtja a "./myscript.sh" parancsvonalat, amely sikeres, mivel a szkript a megadott munkakönyvtárban található.

Tárolófeladat munkakönyvtára

A Batch-tárolófeladatok egy olyan munkakönyvtárban futnak a tárolóban, amely hasonló ahhoz a könyvtárhoz, amelyet a Batch egy normál (nem tárolós) feladathoz állít be. Ez a munkakönyvtár eltér a WORKDIR-től , ha a rendszerképen van konfigurálva, vagy az alapértelmezett tároló munkakönyvtárától (C:\ Windows-tárolón vagy / Linux-tárolón).

Batch-tárolófeladat esetén:

• A gazdacsomópont alatt AZ_BATCH_NODE_ROOT_DIR (az Azure Batch-címtárak gyökerében) lévő összes könyvtár rekurzív módon van leképezve a tárolóba.
• A rendszer minden tevékenységkörnyezeti változót leképez a tárolóba.
• A csomópont feladat-munkakönyvtára AZ_BATCH_TASK_WORKING_DIR ugyanúgy van beállítva, mint egy normál tevékenységnél, és a tárolóba van leképezve.

Ezek a leképezések lehetővé teszik, hogy a tárolótevékenységek ugyanúgy működjenek, mint a nem tárolófeladatok. Alkalmazások telepítése például alkalmazáscsomagokkal, erőforrásfájlok elérése az Azure Storage-ból, tevékenységkörnyezeti beállítások használata és a feladat kimeneti fájljainak megőrzése a tároló leállása után.

Függetlenül attól, hogy a WORKDIR hogyan van beállítva egy tárolólemezképhez, mindkettőt stdout.txt stderr.txt a rendszer rögzíti a AZ_BATCH_TASK_DIR.

Tárolófeladatok hibaelhárítása

Ha a tárolófeladat nem a várt módon fut, előfordulhat, hogy a tárolólemezkép WORKDIR vagy ENTRYPOINT konfigurációjáról kell információt kapnia. A konfiguráció megtekintéséhez futtassa a Docker-rendszerkép vizsgálatának parancsát.

Szükség esetén módosítsa a tárolófeladat beállításait a rendszerkép alapján:

• Adjon meg egy abszolút elérési utat a feladat parancssorában. Ha a rendszerkép alapértelmezett ENTRYPOINT-ját használja a feladat parancssorához, győződjön meg arról, hogy egy abszolút elérési út van beállítva.
• A feladat tárolófuttatási beállításai között módosítsa a munkakönyvtárat úgy, hogy az megfeleljen a képen látható WORKDIR-nek. Például állítsa be a .--workdir /app

Példa tárolófeladatokra

Az alábbi Python-kódrészlet a Docker Hubról lekért fiktív rendszerképből létrehozott tárolóban futó egyszerű parancssort mutatja be. Itt a --rm tárolóbeállítás eltávolítja a tárolót a feladat befejezése után, és a --workdir beállítás beállít egy munkakönyvtárat. A parancssor felülírja a tároló ENTRYPOINT parancsát egy egyszerű rendszerhéj-paranccsal, amely egy kis fájlt ír a gazdagép feladat-munkakönyvtárába.

task_id = 'sampletask'
task_container_settings = batch.models.TaskContainerSettings(
    image_name='myimage',
    container_run_options='--rm --workdir /')
task = batch.models.TaskAddParameter(
    id=task_id,
    command_line='/bin/sh -c \"echo \'hello world\' > $AZ_BATCH_TASK_WORKING_DIR/output.txt\"',
    container_settings=task_container_settings
)

Az alábbi C#-példa egy felhőfeladat alapszintű tárolóbeállítását mutatja be:

// Simple container task command
string cmdLine = "c:\\app\\myApp.exe";

TaskContainerSettings cmdContainerSettings = new TaskContainerSettings (
    imageName: "myimage",
    containerRunOptions: "--rm --workdir c:\\app"
    );

CloudTask containerTask = new CloudTask (
    id: "Task1",
    commandline: cmdLine);
containerTask.ContainerSettings = cmdContainerSettings;

Következő lépések

• A Docker CE Linuxon való telepítésével és használatával kapcsolatos információkért tekintse meg a Docker dokumentációját.
• Megtudhatja, hogyan hozhat létre egyéni rendszerképkészletet felügyelt rendszerképek használatával.
• További információ a Moby projektről, amely egy tárolóalapú rendszerek létrehozásának keretrendszere.