A munkafolyamat megismerése azd up

Az Azure Developer CLI (azd) lehetővé teszi alkalmazáserőforrások üzembe helyezését és üzembe helyezését az Azure-ban egyetlen paranccsal azd up. Ez az útmutató a azd up részletes bontását ismerteti, és azt, hogy a munkafolyamat-parancs különböző szakaszai hogyan kapcsolódnak egy azd sablon szerkezetéhez.

Kövessük végig egy sablon segítségével

Az előttünk álló szakaszok példákat használnak a sablonból a hello-azd különböző azd fogalmak és minták bemutatásához. A sablon helyi gépen való inicializálásával követheti a következőket:

azd init -t hello-azd

Az első lépésekről azd és a hello-azd sablonról további információt az Azure Developer CLI-sablon üzembe helyezéséről szóló rövid útmutatóban talál.

Alapvető fogalmak

Ha azd sablonnal dolgozik, az azd up parancs segítségével telepítheti az alkalmazáserőforrásokat az Azure-on. Futtassa a parancsot a sablonmappához megnyitott terminálablakból:

azd up

azd up úgy lett kialakítva, hogy az alkalmazás fejlesztése során ismételten futtathassa a parancsot, és az új módosítások növekményesen legyenek üzembe helyezve. A parancs egy hatékony munkafolyamatot indít el, amely lényegében három konkrét szakaszt csomagol be:

1. Csomagolás: Előkészíti az alkalmazáskódot és a függőségeket az üzembe helyezéshez.
2. Kiépítés: Létrehozza és konfigurálja az alkalmazás által igényelt szükséges Azure-erőforrásokat infrastruktúra-kódfájlok használatával.
3. Üzembe helyezés: Üzembe helyezi a csomagolt alkalmazást a kiépített Azure-erőforrásokon.

Ezeket a fázisokat egyenként is futtathatja a saját parancsával, de azd up kényelmes burkolót biztosít az általános folyamat gördülékenyebbé tételéhez. Minden fázis kritikus szerepet játszik a zökkenőmentes és automatizált üzembe helyezési folyamat biztosításában. A munkafolyamat szakaszait a azd up sablonfájl azure.yaml konfigurációival befolyásolhatja. Az alábbi szakaszok részletesebben ismertetik az egyes fázisokat.

A csomagolási fázis

A csomagolási szakasz a munkafolyamat első lépése azd up . Ebben a szakaszban:

• Az alkalmazáskód készen áll az üzembe helyezésre. A sablonalkalmazás programozási nyelvétől függően a csomagolás magában foglalhatja az alkalmazás létrehozását vagy összeállítását, függőségek összekapcsolását vagy üzembehelyezési összetevők, például Docker-rendszerképek létrehozását.
• A azd sablonstruktúra általában tartalmaz egy src mappát, amelyben az alkalmazáskód található. Szkriptek vagy konfigurációs fájlok (például Dockerfile) létrehozása befolyásolhatja az alkalmazás csomagolásának módját.
• A azure.yaml fájl konfigurációleképezéseket tartalmaz, amelyekből megtudhatja azd , hogy hol található az alkalmazáskód, és milyen nyelvet használ, így azd megfelelően csomagolhatja be.
• Ez a szakasz biztosítja, hogy az alkalmazás üzembe helyezhető állapotban legyen, mielőtt továbblépne a következő lépésre.

Önállóan is futtathatja a csomagolási folyamatot azd up-n kívül a azd package parancs segítségével.

azd package

Példa csomagolási konfigurációkra

azd különböző nyelvekkel készült alkalmazásokat különböző módokon csomagolhat be. Ha például az alkalmazás tárolóalapú megközelítést használ, előfordulhat, hogy a azd sablon tartalmaz egy Dockerfile alkalmazást az alkalmazáskönyvtárban src . A csomagolási szakasz a fájl alapján létrehoz egy Docker-lemezképet az alkalmazáshoz. Ezek a konfigurációk a azure.yaml fájlon keresztül kezelhetők.

Vegyük például a kezdősablon következő projektstruktúráját és konfigurációit hello-azd :

Az előző képen a azure.yaml fájl:

• A címtárban lévő src kódot C#-alkalmazásként határozza meg.
• Megadja az alkalmazás tárolólemezképének létrehozásához használandó Dockerfile helyét.

Amikor futtatja azd up (vagy azd package), az Azure Developer CLI a konfigurációk ezen kombinációjával hozza létre és csomagolja be az alkalmazáskódot a src könyvtárba .NET-tárolórendszerképként. Ha egy Dockerfile nincs konfigurálva, azd a .NET-alkalmazást is csomagolhatja a szabványos .NET-közzétételi folyamattal.

A kiépítési szakasz

A kiépítési szakasz létrehozza és konfigurálja az alkalmazáshoz szükséges Azure-erőforrásokat. Előfordulhat például, hogy az alkalmazásnak szüksége van egy Azure App Service-példányra az alkalmazás üzemeltetéséhez, és egy Azure Storage-fiókra a feltöltött fájlok tárolásához. A kiépítési szakasz a sablonban található infrastruktúra-kódfájlokat (IaC) használja az erőforrások meghatározásához.

A kiépítési fázissal kapcsolatos néhány fontos tudnivaló:

1. azd A Bicep és a Terraform egyaránt támogatja az infrastruktúra mint kód típusú feladatokat.
2. Alapértelmezés szerint az infrastruktúra kódként tárolt fájljai a infra mappában vannak tárolva, de ez a hely testre szabható.
3. azd keres egy main.bicep vagy main.tf fájlt, amely az IaC-folyamat fő vezénylési fájljaként szolgál.

A kiépítési folyamatot önmagában is futtathatja azd up-n kívül, a azd provision parancs használatával.

azd provision

Példaellátási konfigurációk

infra A mappában általában egy main.bicep fájl határozza meg az alkalmazáshoz létrehozandó Azure-erőforrásokatazd. Vegye figyelembe az alábbi kódrészletet a main.bicep fájlban a hello-azd kezdősablonban:

// ...omitted code for other resource configurations

// Create an Azure Cosmos DB account
module cosmos 'app/cosmos.bicep' = {
  name: 'cosmos'
  scope: rg
  params: {
    userPrincipalId: principalId
    managedIdentityId: identity.outputs.principalId
  }
}

// Create a storage account
module storage './core/storage/storage-account.bicep' = {
  name: 'storage'
  scope: rg
  params: {
    name: !empty(storageAccountName) ? storageAccountName : '${abbrs.storageStorageAccounts}${resourceToken}'
    location: location
    tags: tags
    containers: [
      { name: 'attachments' }
    ]
  }
}

// Container apps environment and registry
module containerAppsEnv './core/host/container-apps.bicep' = {
  name: 'container-apps'
  scope: rg
  params: {
    name: 'app'
    containerAppsEnvironmentName: !empty(containerAppsEnvName) ? containerAppsEnvName : '${abbrs.appManagedEnvironments}${resourceToken}'
    containerRegistryName: !empty(containerRegistryName) ? containerRegistryName : '${abbrs.containerRegistryRegistries}${resourceToken}'
    location: location
  }
}

// ...omitted code for other resource configurations

Az előző Bicep-kód azd használatával hozza létre a következő erőforrásokat:

• Azure Cosmos DB-példány az alkalmazáson keresztül elküldött adatok tárolására
• Feltöltött képek tárolására szolgáló Azure Storage-fiók
• Azure Container App az alkalmazás üzemeltetéséhez

Az üzembe helyezési szakasz

Az üzembe helyezési szakasz a munkafolyamat utolsó lépése azd up . Ebben a szakaszban:

• A csomagolási szakaszban létrehozott alkalmazásösszetevők üzembe lesznek helyezve a kiépített Azure-erőforrásokban.
• azd A sablon konfigurációs fájljait használja, például azure.yamlaz alkalmazás üzembe helyezésének meghatározásához.
• A környezeti változók és a kapcsolati sztringek úgy vannak konfigurálva, hogy az alkalmazás képes legyen kezelni a kiépített erőforrásokat.

A(z) azd up nélküli üzembe helyezési folyamatot a azd deploy parancs használatával is futtathatja.

azd deploy

Példa üzembehelyezési konfigurációkra

azure.yaml A fájlon belül megadhatja, hogy melyik szolgáltatás legyen üzembe helyezve a projektben, melyik Azure-erőforráson. Vegyük például az alábbi konfigurációkat a hello-azd kezdősablonhoz:

metadata:
  template: hello-azd-dotnet
name: azd-starter
services:
  aca:
    project: ./src # The location of the service source code
    language: csharp
    host: containerapp # The provisioned resource to deploy the service to
    docker:
      path: ./Dockerfile

Az előző kód arra utasítja azd, hogy telepítse a src mappában a kódból csomagolt elemeket a containerapp mappába, amelyet a kiépítési szakaszban hoztak létre. Több szolgáltatást is meghatározhat, és mindegyiket egy másik gazdagéphez rendelheti.

Következtetés

A azd up munkafolyamat leegyszerűsíti az alkalmazások Azure-ban való üzembe helyezésének folyamatát a csomagolás, a kiépítés és az üzembe helyezés fázisainak automatizálásával. A fejlesztők konzisztens és hatékony üzembe helyezési folyamatot biztosíthatnak a azd sablonstruktúra betartásával. Akár egyszerű webalkalmazást vagy összetett mikroszolgáltatás-architektúrát helyez üzembe, a azd up parancs leegyszerűsíti a kódból a felhőbe vezető utat.