Az Azure Developer CLI környezeti változóinak használata

Az Azure Developer CLI (azd) környezeti változókkal tárolja és kezeli az üzembehelyezési környezetek konfigurációs beállításait. Ezek a változók szabályozzák az alkalmazás üzembe helyezését, üzembe helyezését és futtatását az Azure-ban. Ez a cikk bemutatja, hogyan működnek azd a környezeti változók a környezetekben, és útmutatást nyújt a hatékony kezelésükhöz.

Környezeti változók ismertetése

Az Azure Developer CLI kontextusában a környezeti változók kulcs-érték párok, amelyek meghatározott nevesített környezetekhez, például dev, test vagy prod környezetekhez vannak kötve. Minden azd környezet saját környezeti változókat tart fenn, így különböző beállításokat konfigurálhat a különböző üzembehelyezési célokhoz.

A környezeti változók a azd mappában lévő környezeti mappákban lévő fájlokban .env.azure vannak tárolva. Bemenetként szolgálnak a következőkhöz:

Alkalmazástelepítési munkafolyamatok
Az Azure-szolgáltatások és -kapcsolatok konfigurációi
Infrastruktúra kiépítése a Bicep és a Terraform használatával

Az operációs rendszer szintjén azd meglévő hagyományos környezeti változókkal ellentétben a környezeti változók a projekt adott környezeteihez tartoznak, így elkülönítve a különböző üzembehelyezési célokat.

A környezeti változók számos fő előnnyel járnak a következőkkel azdvaló munka során:

Környezetelkülönítés: A fejlesztési, tesztelési és éles konfigurációk elkülönítése és megkülönböztetése.
Konfigurációs konzisztencia: Győződjön meg arról, hogy minden csapattag ugyanazokat a beállításokat használja egy adott környezethez.
Infrastruktúra kódként: Az infrastruktúra paraméterezésének meghatározása változókon keresztül, nem pedig rögzített értékeken keresztül.
Üzembe helyezés automatizálása: Engedélyezze a CI/CD-folyamatok üzembe helyezését különböző környezetekben ugyanazzal a kódbázissal, de különböző konfigurációkkal.
Egyszerűsített felügyelet: Egyszerűen frissítheti a beállításokat a környezet összes szolgáltatásában egy központi helyről.

Minden azd környezet saját változókészlettel rendelkezik, amely lehetővé teszi a környezetspecifikus konfigurációkat ugyanazzal az alkalmazáskóddal és infrastruktúrasablonokkal.

Környezeti változók és .env fájlok

A azd környezeti változók a projekt környezetspecifikus könyvtáraiban lévő fájlokban .env vannak tárolva. Amikor környezetet hoz létre a használatával azd env new <name>, létrejön egy könyvtárstruktúra:

.azure/
├── <environment-name>/
│   ├── .env                   # Environment variables for this environment

A .env fájl szabványos formátumot használ, amelyben minden sor egy kulcs-érték párot jelöl:

KEY1=value1
KEY2=value2

Jótanács

A környezetekkel kapcsolatos további információkért tekintse meg a azd című cikket.

Ha például azd upparancsokat futtat, azd automatikusan betölti a változókat a kiválasztott környezet fájljából .env .

Ezek a változók a következőkre vannak hatással:

Infrastruktúra kiépítése: Az erőforrások létrehozásának helyét és AZURE_LOCATION módját változók kedvelik AZURE_SUBSCRIPTION_ID és határozzák meg.
Üzembe helyezés: A szolgáltatásvégpontokhoz hasonló változók szabályozzák, hogy az alkalmazás hogyan csatlakozik az Azure-szolgáltatásokhoz.
Alkalmazáskonfiguráció: A változók átadhatók az alkalmazáskonfigurációnak annak viselkedésének szabályozásához.
Erőforrás-elnevezés: Az olyan változók, mint az AZURE_RESOURCE_GROUP erőforrás-elnevezési minták.

A .env fájl automatikusan azd frissül az olyan műveletek során is, azd initmint például azd provisionaz infrastruktúrasablonok kimeneteinek rögzítése és azd deploykésőbbi használatra való tárolása.

Környezeti változók beállítása

A környezeti változók beállításához azd különböző módszereket használhat a forgatókönyvtől függően.

Parancssori felületi parancsok használata

A környezeti változók beállításának ajánlott módja a azd env set parancs használata, amely az érvényes értékek ellenőrzésére is kiterjed:

azd env set <key> <value>

Például az alkalmazás konfigurációs értékének beállításához:

azd env set API_TIMEOUT 5000

A parancs hozzáadja vagy frissíti a változót az .env aktuálisan kijelölt környezet fájljában. A jelölővel --environment egy adott környezetet is megcélozhat:

azd env set API_TIMEOUT 5000 --environment prod

Annak ellenőrzése, hogy a környezeti változó helyesen lett-e beállítva:

azd env get-value API_TIMEOUT

Kimenet a Bicepből

A hatékony funkció azd az, hogy képes automatikusan rögzíteni a kimeneti paramétereket a Bicep-infrastruktúrasablonokból környezeti változókként. Ha például egy kimeneti paramétert határoz meg a main.bicep fájlban:

output API_ENDPOINT string = apiService.outputs.SERVICE_ENDPOINT_URL

A futtatás azd provisionután a rendszer automatikusan menti a kimenetet a környezet fájljára .env :

API_ENDPOINT=https://api-dev-123456.azurewebsites.net

Ez a megközelítés biztosítja, hogy az alkalmazás mindig hozzáférhessen a legfrissebb erőforrás-információkhoz, például:

Szolgáltatásvégpontok és URL-címek
Erőforrásnevek és -azonosítók

Környezeti változók lekérése és használata

A beállítás után több környezetben is hozzáférhet a környezeti változókhoz.

PARANCSSOR-parancsok

Az aktuális környezet összes környezeti változójának megtekintése:

azd env get-values

Egy adott változó értékének megtekintése:

azd env get-value API_ENDPOINT

Géppel olvasható kimenet esetén (szkriptekben hasznos):

azd env get-values --output json

Környezeti változók használata infrastruktúrafájlokban

Környezeti változókkal testre szabhatja az infrastruktúrasablonokat. Ez hasznos az erőforrások elnevezéséhez, címkézéséhez vagy konfigurálásához az aktuális környezet alapján. azd címkék használatával is megkeresheti az Azure-ban az üzembe helyezéshez és más feladatokhoz szükséges erőforrásokat.

Vegye figyelembe a következő gyakori folyamatot:

azd init A folyamat során azdezeket a környezeti változókat a felhasználó válasza alapján állítja be a következő kérdésekre:
```
AZURE_ENV_NAME=myapp-dev
AZURE_LOCATION=eastus2
```

Hivatkozzon ezekre a változókra a main.parameters.json mappábaninfra. azd a kiépítés során lecseréli az értékeket, és átadja a feloldott paramétereket a Bicep-nek:

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentParameters.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "name": {
      "value": "${AZURE_ENV_NAME}"
    },
    "location": {
      "value": "${AZURE_LOCATION}"
    }
  }
}

Egyező paraméterek definiálása a Bicep-sablonban:

@description('Name of the environment used to derive resource names and tags.')
param name string

@minLength(1)
@description('Primary Azure region for all resources.')
param location string

azd ezeket a Bicep-paramétereket a helyettesítő értékekkel látja el a következőben main.parameters.json: .

Az erőforrások elnevezésének és címkéinek paramétereivel később megállapíthatja, hogy az erőforrás melyik környezethez tartozik:

var resourceToken = toLower(uniqueString(resourceGroup().id, name, location))

resource storageAccount 'Microsoft.Storage/storageAccounts@2022-09-01' = {
  name: 'st${resourceToken}'
  location: location
  sku: {
    name: 'Standard_LRS'
  }
  kind: 'StorageV2'
  tags: {
    Environment: name
    Project: 'myproject'
  }
}

Ez a minta rugalmasan tartja a sablonokat, lehetővé teszi a környezetenkénti testreszabást kódmódosítások nélkül, és javítja az erőforrás-szabályozást (elnevezés, címkézés és felderítés).

Megjegyzés:

azd Emellett a címkézésre is támaszkodik az Azure-erőforrások üzembe helyezési szakaszában való megkereséséhez.

Hookok

azd A környezeti változók automatikusan előre vannak betöltve, és elérhetők a fájlban definiált horgokban és egyéni szkriptekben azure.yaml . A környezeti változók az alábbi szintaxissal érhetők el:

Bash
PowerShell

# Use the variables in your script
echo "API endpoint: $API_ENDPOINT"
echo "Deploying to: $AZURE_LOCATION"

# Use the variables in your script
Write-Host "API endpoint: $API_ENDPOINT"
Write-Host "Deploying to: $AZURE_LOCATION"

A fájlban definiálhat horgokat, azure.yaml hogy az életciklus meghatározott pontjain futtassa ezeket a azd szkripteket:

hooks:
  postprovision:
    windows:
      shell: pwsh
      run: ./scripts/load-env-vars.ps1
      interactive: false
    posix:
      shell: sh
      run: ./scripts/load-env-vars.sh
      interactive: false

Jótanács

A horogok használatával kapcsolatos további információkért tekintse meg a munkafolyamatok testreszabása horoggal foglalkozó cikket.

Változók eltávolítása vagy frissítése

Változó eltávolítása a környezetből:

azd env unset VARIABLE_NAME

Meglévő változó frissítése:

azd env set VARIABLE_NAME "new-value"

A helyi környezeti változók frissítése az Azure-erőforrások aktuális állapotából:

azd env refresh

A környezet frissítése akkor hasznos, ha:

Biztosítani szeretné, hogy a helyi .env fájl tükrözze az infrastruktúra legújabb kimeneteit (például kapcsolati sztringeket, végpontokat stb.).
Miután egy csapattag frissítette a környezetet, szinkronizálnia kell a környezeti változókat.

AZD és operációs rendszer környezeti változói

azd a környezeti változók és az operációs rendszer környezeti változói különböző célokat szolgálnak, és különböző módokon működnek:

Fogalom	Azure Developer CLI	Operációs rendszer
Elhelyezkedés	Fájlokban `.azure/<env-name>/.env` tárolva	Beállítás az operációs rendszer környezetében
Scope	Hatókör egy projekt adott nevesített környezetére	Globális a felhasználói munkamenet vagy rendszer számára
Menedzsment	Kezelés parancsokkal `azd env`	Operációsrendszer-specifikus parancsok (`export`stb `set`.) használatával felügyelve
Access	Parancsok automatikusan betöltve `azd`	Általában explicit módon töltődik be szkriptekbe vagy alkalmazásokba
Target	Azure-erőforrásokhoz és üzemelő példányokhoz kötve	Általános célú rendszerkonfiguráció
Életciklus	Állandósulás a terminál munkamenetei között	A beállításuktól függően ideiglenes vagy állandó lehet

azd az operációs rendszer környezeti változóinak olvasása és írása nem történik meg automatikusan. Azonban mindkét változótípust használhatja egyéni szkriptek használatával.

Környezeti változók és operációsrendszer-környezeti változók olvasásaazd:

Bash
PowerShell

# Access OS environment variable
echo "OS variable: $PATH"

# Access azd environment variable
echo "AZD variable: $(azd env get-value MY_VARIABLE)"

# Access OS environment variable
Write-Host "OS variable: $env:PATH"

# Access azd environment variable
Write-Host "AZD variable: $(azd env get-value MY_VARIABLE)"

Környezeti változók írása azd operációs rendszerre vagy keretrendszer környezeti változókra:

Bash
PowerShell

# Load all azd environment variables into the current shell session
while IFS='=' read -r key value; do
    value=$(echo "$value" | sed 's/^"//' | sed 's/"$//')
    export "$key=$value"
done <<EOF
$(azd env get-values)
EOF

# Load all azd environment variables into the current PowerShell session
foreach ($line in (& azd env get-values)) {
    if ($line -match "([^=]+)=(.*)") {
        $key = $matches[1]
        $value = $matches[2] -replace '^"|"$'
        $env:$key = $value
    }
}

Standard környezeti változók

azd számos gyakori környezeti változót állít be és használ minden környezetben:

Variable	Leírás	Example	Amikor be van állítva
`AZURE_ENV_NAME`	Az aktuális környezet neve	`dev`	Környezet létrehozásakor
`AZURE_LOCATION`	Azure-régió, ahol az erőforrások üzembe vannak helyezve	`eastus`	Az első üzembe helyezés során
`AZURE_SUBSCRIPTION_ID`	A használt Azure-előfizetés azonosítója	`00000000-0000-0000-0000-000000000000`	Az első üzembe helyezés során
`AZURE_RESOURCE_GROUP`	Az erőforráscsoport neve	`rg-myapp-dev`	A kiépítés során
`AZURE_PRINCIPAL_ID`	A futó felhasználó/szolgáltatásnév azonosítója	`00000000-0000-0000-0000-000000000000`	A kiépítés során
`AZURE_PRINCIPAL_TYPE`	A rendszernév típusa a környezetben.	`1a2b3c`	A kiépítés során
`AZURE_TENANT_ID`	A használt Azure-bérlő azonosítója.	`00000000-0000-0000-0000-000000000000`	A kiépítés során

Titkos kódok és bizalmas adatokkal kapcsolatos szempontok

Bár a környezeti változók kényelmesen konfigurálhatóak, speciális kezelést igényelnek a bizalmas adatokhoz:

Kerülje a titkos kulcsok .env fájlokban való tárolását

.env a fájlok általában egyszerű szövegben vannak tárolva, és könnyen tárolhatók:

Véletlenül elkötelezte magát a forráskövetés mellett
Megosztás vagy másolás megfelelő védelem nélkül
Bárki megtekintheti, aki hozzáfér a projektfájlokhoz
Naplókban vagy hibajelentésekben szerepel

Figyelmeztetés

Soha ne tároljon titkos kulcsokat egy Azure Developer CLI-fájlban .env . Ezek a fájlok egyszerűen megoszthatók vagy másolhatók jogosulatlan helyekre, vagy be lehet jelentkezni a forrásvezérlőbe. Védett vagy titkos megoldásokhoz használjon olyan szolgáltatásokat, mint az Azure Key Vault vagy az Azure Role Based Access Control (RBAC).

A titkos kódok kezelésének alternatívái

Bizalmas adatok esetén vegye figyelembe az alábbi biztonságosabb módszereket:

Azure Key Vault-hivatkozások: Titkos kulcsokat tárol az Azure Key Vaultban, és hivatkozzon rájuk a .env fájlban:
```
azd env set-secret <secret-value>
```
Ez a parancs létrehoz egy Key Vault-titkos kulcsot, és a tényleges érték helyett a fájlban .env tárolja az arra mutató hivatkozást.
Felügyelt identitások: Konfigurálja az Azure-szolgáltatásokat úgy, hogy a kapcsolati sztringek vagy hozzáférési kulcsok helyett felügyelt identitásokat használjon.
Környezetspecifikus biztonság: Szigorúbb biztonsági vezérlőket alkalmazhat az éles környezetekre, mint a fejlesztési környezetekre.
Just-in-time titkos kulcsok: Rövid élettartamú hitelesítő adatok létrehozása az üzembe helyezés során az állandó titkos kulcsok tárolása helyett.

Következő lépések

Környezetek használata az Azure Developer CLI-ben Az Azure Developer CLI-munkafolyamatok testreszabása horogokkal

Visszajelzés

Hasznosnak találta ezt az oldalt?

Last updated on 2025-08-16