Konfigurera containeravbildning för att köra distributioner

Azure Deployment Environments (ADE) stöder en utökningsmodell som gör att du kan konfigurera din miljödefinition med ditt önskade IaC-mallramverk. Du kan lagra anpassade avbildningar i ett containerregister som Azure Container Registry (ACR) eller Docker Hub och sedan referera till dem i miljödefinitionerna för att distribuera miljöer.

I den här artikeln får du lära dig hur du skapar anpassade Bicep-containeravbildningar för att distribuera dina miljödefinitioner i ADE. Du lär dig hur du använder en standardbild från Microsoft eller hur du konfigurerar en infrastruktur för anpassad avbildningsetablering med hjälp av ramverket Bicep Infrastructure-as-Code (IaC).

I den här artikeln får du lära dig hur du skapar anpassade Terraform-containeravbildningar för att skapa distributionsmiljöer med Azure Deployment Environments (ADE). Du lär dig hur du konfigurerar en anpassad avbildning för att etablera infrastruktur med hjälp av Terraform Infrastructure-as-Code-ramverket (IaC).

I den här artikeln får du lära dig hur du använder Pulumi för distributioner i ADE. Du lär dig hur du använder en standardbild som tillhandahålls av Pulumi eller hur du konfigurerar en anpassad avbildning för att etablera infrastruktur med hjälp av Pulumi Infrastructure-as-Code-ramverket (IaC).

Förutsättningar

• Ett Azure-konto med en aktiv prenumeration. Skapa ett konto utan kostnad.
• Azure-distributionsmiljöer som konfigurerats i din Azure-prenumeration.
  • Om du vill konfigurera ADE följer du snabbstarten : Konfigurera Azure-distributionsmiljöer.

Använda containeravbildningar med ADE

Du kan använda någon av följande metoder för att använda containeravbildningar med ADE:

• Använd en standardcontaineravbildning För enkla scenarier använder du standard-ARM-Bicep-containeravbildningen som tillhandahålls av ADE.
• Skapa en anpassad containeravbildning För mer komplexa scenarier skapar du en anpassad containeravbildning som uppfyller dina specifika krav.

Använda en standardcontaineravbildning

ADE stöder Azure Resource Manager (ARM) och Bicep utan extra konfiguration. Du kan skapa en miljödefinition som distribuerar Azure-resurser för en distributionsmiljö genom att lägga till mallfilerna (till exempel azuredeploy.json och environment.yaml) i katalogen. ADE använder sedan standard-ARM-Bicep-containeravbildningen för att skapa distributionsmiljön.

I filen runner environment.yaml anger egenskapen platsen för den containeravbildning som du vill använda. Om du vill använda standardbilden som publicerats på Microsofts artefaktregister använder du respektive identifierare runner.

I följande exempel visas en runner som refererar till standardavbildningen för ARM-Bicep-containern:

    name: WebApp
    version: 1.0.0
    summary: Azure Web App Environment
    description: Deploys a web app in Azure without a datastore
    runner: Bicep
    templatePath: azuredeploy.json

Du kan se standard-Bicep-containeravbildningen i ADE-standardlagringsplatsen under mappen Runner-Images för ARM-Bicep-avbildningen .

Mer information om hur du skapar miljödefinitioner som använder ADE-containeravbildningarna för att distribuera dina Azure-resurser finns i Lägga till och konfigurera en miljödefinition.

Skapa en anpassad containeravbildning

Skapa en anpassad avbildning med hjälp av ett skript

Skapa en anpassad containeravbildning med hjälp av ett skript

När du skapar en anpassad containeravbildning kan du anpassa dina distributioner så att de passar dina behov. Du kan skapa och skapa en avbildning baserat på ADE-standardavbildningen och skicka den till containerregistret med hjälp av ett snabbstartsskript från Microsoft. Du hittar skriptet i lagringsplatsen Distributionsmiljöer. Om du vill använda snabbstartsskriptet förgrenar du lagringsplatsen och kör sedan skriptet lokalt.

Skriptet skapar en avbildning och skickar den till det angivna Azure Container Registry (ACR) under lagringsplatsen "ade" och taggen "latest". Det här skriptet kräver ditt registernamn och din katalog för din anpassade avbildning, har Azure CLI och Docker Desktop installerat och i path-variablerna och kräver att du har behörighet att skicka till det angivna registret.

Om du vill använda snabbstartsskriptet för att snabbt skapa och skicka den här exempelavbildningen till ett Azure Container Registry måste du:

• Förgrena den här lagringsplatsen till ditt personliga konto.
• Se till att Azure CLI och Docker Desktop-programmet är installerade på datorn och i path-variablerna.
• Kontrollera att du har behörighet att skicka avbildningar till ditt valda Azure Container Registry.

Du kan anropa skriptet med följande kommando i PowerShell:

.\quickstart-image-build.ps1 -Registry '{YOUR_REGISTRY}' -Directory '{DIRECTORY_TO_YOUR_IMAGE}'

Om du vill skicka till en specifik lagringsplats och taggnamn kan du dessutom köra:

.\quickstart-image.build.ps1 -Registry '{YOUR_REGISTRY}' -Directory '{DIRECTORY_TO_YOUR_IMAGE}' -Repository '{YOUR_REPOSITORY}' -Tag '{YOUR_TAG}'

Om du vill använda avbildningen i dina miljödistributioner måste du lägga till avbildningens plats i manifestfilen Anslut avbildningen till din miljödefinition och du kan behöva konfigurera behörigheter för ACR för att göra den anpassade avbildningen tillgänglig för ADE.

Skapa en anpassad avbildning manuellt

Skapa en anpassad containeravbildning manuellt

När du skapar en anpassad containeravbildning kan du anpassa dina distributioner så att de passar dina behov. Du kan skapa anpassade avbildningar baserat på ADE-standardbilderna.

När du har slutfört avbildningsanpassningen kan du skapa avbildningen och skicka den till containerregistret manuellt.

Du skapar anpassade avbildningar med ADE-standardavbildningarna som bas med ADE CLI, som är förinstallerat på standardavbildningarna. Mer information om ADE CLI finns i referensen för CLI Custom Runner Image.

I det här exemplet får du lära dig hur du skapar en Docker-avbildning för att använda ADE-distributioner och komma åt ADE CLI och baserar avbildningen på en av de ADE-skapade avbildningarna.

Följ dessa steg för att skapa en avbildning som konfigurerats för ADE:

1. Skapa en anpassad avbildning baserat på en standardbild.
2. Installera önskade paket.
3. Konfigurera åtgärdsgränssnittsskript.
4. Skapa åtgärdsgränssnittsskript för att distribuera ARM- eller Bicep-mallar.

1. Skapa en anpassad avbildning baserat på en standardbild

Skapa en DockerFile som innehåller en FROM-instruktion som pekar på en standardbild som finns på Microsofts artefaktregister.

Här är ett exempel på FROM-instruktionen som refererar till standardkärnbilden:

FROM mcr.microsoft.com/deployment-environments/runners/core:latest

Den här instruktionen hämtar den senast publicerade kärnbilden och utgör grunden för din anpassade avbildning.

2. Installera nödvändiga paket

I det här steget installerar du alla paket som du behöver i avbildningen, inklusive Bicep. Du kan installera Bicep-paketet med Azure CLI med hjälp av RUN-instruktionen, som du ser i följande exempel:

RUN az bicep install

ADE-standardavbildningarna baseras på Azure CLI-avbildningen och har ADE CLI- och JQ-paketen förinstallerade. Du kan lära dig mer om Azure CLI och JQ-paketet.

Om du vill installera fler paket som du behöver i avbildningen använder du RUN-instruktionen.

3. Konfigurera åtgärdsgränssnittsskript

I standardbilderna bestäms och körs åtgärder baserat på åtgärdsnamnet. För närvarande distribueras och tas de två åtgärdsnamnen som stöds bort.

Om du vill konfigurera din anpassade avbildning för att använda den här strukturen anger du en mapp på nivån för dina Dockerfile-namngivna skript och anger två filer, deploy.sh och delete.sh. Distributionsgränssnittsskriptet körs när din miljö skapas eller distribueras om, och borttagningsgränssnittsskriptet körs när din miljö tas bort. Du kan se exempel på shell-skript på lagringsplatsen under mappen Runner-Images för ARM-Bicep-avbildningen .

För att säkerställa att dessa gränssnittsskript är körbara lägger du till följande rader i Dockerfile:

COPY scripts/* /scripts/
RUN find /scripts/ -type f -iname "*.sh" -exec dos2unix '{}' '+'
RUN find /scripts/ -type f -iname "*.sh" -exec chmod +x {} \;

4. Skapa åtgärdsgränssnittsskript för att distribuera ARM- eller Bicep-mallar

För att säkerställa att du kan distribuera ARM- eller Bicep-infrastrukturen via ADE måste du:

1. Konvertera ADE-parametrar till ARM-godtagbara parametrar
2. Lösa länkade mallar om de används i distributionen
3. Använda privilegierad hanterad identitet för att utföra distributionen

Under kärnbildens startpunkt lagras alla parametrar som angetts för den aktuella miljön under variabeln $ADE_OPERATION_PARAMETERS. För att konvertera dem till ARM-godtagbara parametrar kan du köra följande kommando med JQ:

# format the parameters as arm parameters
deploymentParameters=$(echo "$ADE_OPERATION_PARAMETERS" | jq --compact-output '{ "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentParameters.json#", "contentVersion": "1.0.0.0", "parameters": (to_entries | if length == 0 then {} else (map( { (.key): { "value": .value } } ) | add) end) }' )

För att lösa eventuella länkade mallar som används i en ARM JSON-baserad mall kan du sedan dekompilera huvudmallfilen, som löser alla lokala infrastrukturfiler som används i många Bicep-moduler. Återskapa sedan modulerna i en enda ARM-mall med de länkade mallarna inbäddade i arm-huvudmallen som kapslade mallar. Det här steget är bara nödvändigt under distributionsåtgärden. Huvudmallfilen kan anges med hjälp av $ADE_TEMPLATE_FILE uppsättningen under kärnavbildningens startpunkt, och du bör återställa den här variabeln med den omkompilerade mallfilen. Se följande exempel:

if [[ $ADE_TEMPLATE_FILE == *.json ]]; then

    hasRelativePath=$( cat $ADE_TEMPLATE_FILE | jq '[.. | objects | select(has("templateLink") and (.templateLink | has("relativePath")))] | any' )

    if [ "$hasRelativePath" = "true" ]; then
        echo "Resolving linked ARM templates"

        bicepTemplate="${ADE_TEMPLATE_FILE/.json/.bicep}"
        generatedTemplate="${ADE_TEMPLATE_FILE/.json/.generated.json}"

        az bicep decompile --file "$ADE_TEMPLATE_FILE"
        az bicep build --file "$bicepTemplate" --outfile "$generatedTemplate"

        # Correctly reassign ADE_TEMPLATE_FILE without the $ prefix during assignment
        ADE_TEMPLATE_FILE="$generatedTemplate"
    fi
fi

Om du vill ge de behörigheter som en distribution kräver för att köra distributionen och borttagningen av resurser i prenumerationen använder du den privilegierade hanterade identitet som är associerad med ADE-projektmiljötypen. Om distributionen behöver särskilda behörigheter för att slutföras, till exempel särskilda roller, tilldelar du dessa roller till projektmiljötypens identitet. Ibland är den hanterade identiteten inte omedelbart tillgänglig när du anger containern. du kan försöka igen tills inloggningen har slutförts.

echo "Signing into Azure using MSI"
while true; do
    # managed identity isn't available immediately
    # we need to do retry after a short nap
    az login --identity --allow-no-subscriptions --only-show-errors --output none && {
        echo "Successfully signed into Azure"
        break
    } || sleep 5
done

Kör kommandot för att påbörja distributionen av ARM- eller Bicep-mallarna az deployment group create . När du kör det här kommandot i containern väljer du ett distributionsnamn som inte åsidosätter några tidigare distributioner och använder flaggorna --no-prompt true och --only-show-errors för att säkerställa att distributionen inte misslyckas vid varningar eller stopp vid väntan på användarindata, som du ser i följande exempel:

deploymentName=$(date +"%Y-%m-%d-%H%M%S")
az deployment group create --subscription $ADE_SUBSCRIPTION_ID \
    --resource-group "$ADE_RESOURCE_GROUP_NAME" \
    --name "$deploymentName" \
    --no-prompt true --no-wait \
    --template-file "$ADE_TEMPLATE_FILE" \
    --parameters "$deploymentParameters" \
    --only-show-errors

Om du vill ta bort en miljö utför du en distribution i fullständigt läge och tillhandahåller en tom ARM-mall som tar bort alla resurser i den angivna ADE-resursgruppen, enligt följande exempel:

deploymentName=$(date +"%Y-%m-%d-%H%M%S")
az deployment group create --resource-group "$ADE_RESOURCE_GROUP_NAME" \
    --name "$deploymentName" \
    --no-prompt true --no-wait --mode Complete \
    --only-show-errors \
    --template-file "$DIR/empty.json"

Du kan kontrollera etableringstillståndet och informationen genom att köra kommandona nedan. ADE använder vissa specialfunktioner för att läsa och ge mer kontext baserat på etableringsinformationen, som du hittar i mappen Runner-Images . En enkel implementering kan vara följande:

if [ $? -eq 0 ]; then # deployment successfully created
    while true; do

        sleep 1

        ProvisioningState=$(az deployment group show --resource-group "$ADE_RESOURCE_GROUP_NAME" --name "$deploymentName" --query "properties.provisioningState" -o tsv)
        ProvisioningDetails=$(az deployment operation group list --resource-group "$ADE_RESOURCE_GROUP_NAME" --name "$deploymentName")

        echo "$ProvisioningDetails"

        if [[ "CANCELED|FAILED|SUCCEEDED" == *"${ProvisioningState^^}"* ]]; then

            echo -e "\nDeployment $deploymentName: $ProvisioningState"

            if [[ "CANCELED|FAILED" == *"${ProvisioningState^^}"* ]]; then
                exit 11
            else
                break
            fi
        fi
    done
fi

Om du vill visa utdata från distributionen och skicka dem till ADE för att göra dem tillgängliga via Azure CLI kan du köra följande kommandon:

deploymentOutput=$(az deployment group show -g "$ADE_RESOURCE_GROUP_NAME" -n "$deploymentName" --query properties.outputs)
if [ -z "$deploymentOutput" ]; then
    deploymentOutput="{}"
fi
echo "{\"outputs\": $deploymentOutput}" > $ADE_OUTPUTS

Skapa den anpassade avbildningen

Du kan skapa avbildningen med Hjälp av Docker CLI. Kontrollera att Docker-motorn är installerad på datorn. Navigera sedan till katalogen för din Dockerfile och kör följande kommando:

docker build . -t {YOUR_REGISTRY}.azurecr.io/{YOUR_REPOSITORY}:{YOUR_TAG}

Om du till exempel vill spara avbildningen under en lagringsplats i registret med namnet customImageoch ladda upp med taggversionen av 1.0.0kör du:

docker build . -t {YOUR_REGISTRY}.azurecr.io/customImage:1.0.0

Använda containeravbildningar med ADE

Du kan använda någon av följande metoder för att använda containeravbildningar med ADE:

• Skapa en anpassad containeravbildning med hjälp av ett skript: Använd det publicerade skriptet för att skapa en Terraform-specifik avbildning.
• Skapa en anpassad containeravbildning som utnyttjar ett GitHub-arbetsflöde: Använd det publicerade GitHub-arbetsflödet från ADE:s utökningsmodell med Terraform-lagringsplatsen.
• Skapa en anpassad containeravbildning manuellt: Skapa en anpassad Terraform-specifik avbildning manuellt

Skapa en anpassad containeravbildning

Skapa en avbildning med hjälp av ett skript

Skapa en anpassad containeravbildning med hjälp av ett skript

När du skapar en anpassad containeravbildning kan du anpassa dina distributioner så att de passar dina behov. Du kan skapa en avbildning baserat på ADE-standardavbildningen och skicka den till containerregistret med hjälp av ett snabbstartsskript från Microsoft. Du hittar skriptet i distributionsmiljöerna med Terraform-lagringsplatsen. Om du vill använda snabbstartsskriptet förgrenar du lagringsplatsen och kör sedan skriptet lokalt.

Om du vill använda snabbstartsskriptet för att snabbt skapa och skicka den här exempelavbildningen till ett Azure Container Registry måste du:

• Förgrena den här lagringsplatsen till ditt personliga konto.
• Se till att Azure CLI och Docker Desktop-programmet är installerade på datorn och i path-variablerna.
• Kontrollera att du har behörighet att skicka avbildningar till ditt valda Azure Container Registry.

Skriptet skapar en avbildning och skickar den till det angivna Azure Container Registry (ACR) under lagringsplatsen "ade" och taggen "latest". Det här skriptet kräver ditt registernamn och din katalog för din anpassade avbildning, har Azure CLI och Docker Desktop installerat och i path-variablerna och kräver att du har behörighet att skicka till det angivna registret. Du kan anropa skriptet med följande kommando i PowerShell:

.\quickstart-image-build.ps1 -Registry '{YOUR_REGISTRY}' -Directory '{DIRECTORY_TO_YOUR_IMAGE}'

Om du vill skicka till en specifik lagringsplats och taggnamn kan du dessutom köra:

.\quickstart-image.build.ps1 -Registry '{YOUR_REGISTRY}' -Directory '{DIRECTORY_TO_YOUR_IMAGE}' -Repository '{YOUR_REPOSITORY}' -Tag '{YOUR_TAG}'

Om du vill använda avbildningen i dina miljödistributioner måste du lägga till avbildningens plats i manifestfilen Anslut avbildningen till din miljödefinition och du kan behöva konfigurera behörigheter för ACR för att göra den anpassade avbildningen tillgänglig för ADE.

Skapa en avbildning med ett GitHub-arbetsflöde

Skapa en anpassad containeravbildning med hjälp av ett GitHub-arbetsflöde

Till att börja med kan du använda det publicerade GitHub-arbetsflödet från ADE:s utökningsmodell med Terraform-lagringsplatsen.

För att kunna använda arbetsflödet måste du:

• Förgrena den här lagringsplatsen till ditt personliga konto
• Tillåt att GitHub Actions ansluter till Azure via ett Microsoft Entra-ID-programs federerade autentiseringsuppgifter via OIDC. Mer dokumentation om den här processen finns här
• Konfigurera Lagringsplatshemligheter för din lagringsplats som innehåller ditt Microsoft Entra-ID-programs program-ID som AZURE_CLIENT_ID, prenumerations-ID:t som AZURE_SUBSCRIPTION_ID och klientorganisations-ID:t som AZURE_TENANT_ID
• Konfigurera lagringsplatsvariabler för din lagringsplats som innehåller ditt personliga Azure Container Registry-namn (ACR) som REGISTRY_NAME, det önskade lagringsplatsens namn som REPOSITORY_NAME och din önskade tagg som TAGG för den skapade avbildningen. Du kan ändra variablerna mellan arbetsflödeskörningar för att skicka den genererade avbildningen till olika register, lagringsplatser och taggar.

Kör arbetsflödet genom att gå till fliken Åtgärder på din förgrenade lagringsplats och välja det arbetsflöde som du vill köra. Du kan sedan välja knappen Kör arbetsflöde för att starta arbetsflödet.

Om du vill använda avbildningen i dina miljödistributioner måste du lägga till avbildningens plats i manifestfilen Anslut avbildningen till din miljödefinition och du kan behöva konfigurera behörigheter för ACR för att göra den anpassade avbildningen tillgänglig för ADE.

Skapa en avbildning manuellt

Skapa en anpassad containeravbildning manuellt

När du skapar en anpassad containeravbildning kan du anpassa dina distributioner så att de passar dina behov. Du kan skapa anpassade avbildningar baserat på ADE-standardbilderna.

När du har slutfört avbildningsanpassningen måste du skapa avbildningen och push-överföra den till containerregistret.

Du kan skapa och push-överföra avbildningen manuellt eller använda ett skript från Microsoft för att automatisera processen.

Den publicerade GitHub-åtgärden hjälper till att skapa och skicka en avbildning till ett Azure Container Registry (ACR). Du kan referera till en angivet ACR-avbildningslänk i en miljödefinition i ADE för att distribuera eller ta bort en miljö med den angivna avbildningen.

Följ dessa steg för att skapa en avbildning som konfigurerats för ADE:

1. Skapa en anpassad avbildning baserat på ett GitHub-arbetsflöde.
2. Installera önskade paket.
3. Konfigurera åtgärdsgränssnittsskript.
4. Skapa åtgärdsgränssnittsskript som använder Terraform CLI.

1. Skapa en anpassad avbildning baserat på ett GitHub-arbetsflöde

Använd den publicerade lagringsplatsen för att dra nytta av GitHub-arbetsflödet. Lagringsplatsen innehåller ADE-kompatibla exempelavbildningskomponenter, inklusive ett Dockerfile- och shell-skript för att distribuera och ta bort miljöer med Terraform IaC-mallar. Den här exempelkoden hjälper dig att skapa en egen containeravbildning.

2. Installera nödvändiga paket I det här steget installerar du alla paket som du behöver i avbildningen, inklusive Terraform. Du kan installera Terraform CLI på en körbar plats så att den kan användas i distributions- och borttagningsskripten.

Här är ett exempel på den processen som installerar version 1.7.5 av Terraform CLI:

RUN wget -O terraform.zip https://releases.hashicorp.com/terraform/1.7.5/terraform_1.7.5_linux_amd64.zip
RUN unzip terraform.zip && rm terraform.zip
RUN mv terraform /usr/bin/terraform

Dricks

Du kan hämta nedladdnings-URL:en för din föredragna version av Terraform CLI från Hashicorp-versioner.

3. Konfigurera åtgärdsgränssnittsskript

I standardbilderna bestäms och körs åtgärder baserat på åtgärdsnamnet. För närvarande distribueras och tas de två åtgärdsnamnen som stöds bort.

Om du vill konfigurera din anpassade avbildning för att använda den här strukturen anger du en mapp på nivån för dina Dockerfile-namngivna skript och anger två filer, deploy.sh och delete.sh. Distributionsgränssnittsskriptet körs när din miljö skapas eller distribueras om, och borttagningsgränssnittsskriptet körs när din miljö tas bort. Du kan se exempel på shell-skript på lagringsplatsen i skriptmappen för Terraform.

För att säkerställa att dessa gränssnittsskript är körbara lägger du till följande rader i Dockerfile:

COPY scripts/* /scripts/
RUN find /scripts/ -type f -iname "*.sh" -exec dos2unix '{}' '+'
RUN find /scripts/ -type f -iname "*.sh" -exec chmod +x {} \;

4. Skapa åtgärdsgränssnittsskript som använder Terraform CLI

Det finns tre steg för att distribuera infrastruktur via Terraform:

1. terraform init – initierar Terraform CLI för att utföra åtgärder i arbetskatalogen
2. terraform plan– utvecklar en plan baserat på inkommande Terraform-infrastrukturfiler och variabler samt eventuella befintliga tillståndsfiler och utvecklar de steg som krävs för att skapa eller uppdatera infrastrukturen som anges i .tf-filerna
3. terraform apply – tillämpar planen för att skapa ny eller uppdatera befintlig infrastruktur i Azure

Under kärnavbildningens startpunkt hämtas alla befintliga tillståndsfiler till containern och katalogen sparas under miljövariabeln $ADE_STORAGE. Dessutom har alla parametrar som angetts för den aktuella miljön som lagras under variabeln $ADE_OPERATION_PARAMETERS. Kör följande kommandon för att komma åt den befintliga tillståndsfilen och ange variablerna i en .tfvars.json fil:

set -e #set script to exit on error
EnvironmentState="$ADE_STORAGE/environment.tfstate"
EnvironmentPlan="/environment.tfplan"
EnvironmentVars="/environment.tfvars.json"

echo "$ADE_OPERATION_PARAMETERS" > $EnvironmentVars

För att kunna använda ADE-behörigheter för att distribuera infrastruktur i din prenumeration måste skriptet dessutom använda MSI (Managed Service Identity) när du etablerar infrastruktur med hjälp av Terraform AzureRM-providern. Om distributionen behöver särskilda behörigheter för att slutföra distributionen, till exempel särskilda roller, tilldelar du dessa behörigheter till den projektmiljötyps identitet som används för din miljödistribution. ADE anger relevanta miljövariabler, till exempel klient-, klient- och prenumerations-ID:t i kärnbildens startpunkt, så kör följande kommandon för att säkerställa att providern använder ADE MSI:

export ARM_USE_MSI=true
export ARM_CLIENT_ID=$ADE_CLIENT_ID
export ARM_TENANT_ID=$ADE_TENANT_ID
export ARM_SUBSCRIPTION_ID=$ADE_SUBSCRIPTION_ID

Om du har andra variabler att referera till i mallen som inte anges i miljöns parametrar anger du miljövariabler med hjälp av prefixet TF_VAR. En lista över angivna ADE-miljövariabler tillhandahålls som cli-variabelreferens för Azure Deployment Environment. Ett exempel på dessa kommandon kan vara;

export TF_VAR_resource_group_name=$ADE_RESOURCE_GROUP_NAME
export TF_VAR_ade_env_name=$ADE_ENVIRONMENT_NAME
export TF_VAR_env_name=$ADE_ENVIRONMENT_NAME
export TF_VAR_ade_subscription=$ADE_SUBSCRIPTION_ID
export TF_VAR_ade_location=$ADE_ENVIRONMENT_LOCATION
export TF_VAR_ade_environment_type=$ADE_ENVIRONMENT_TYPE

Nu kan du köra stegen som angavs tidigare för att initiera Terraform CLI, generera en plan för etableringsinfrastruktur och tillämpa en plan under distributionsskriptet:

terraform init
terraform plan -no-color -compact-warnings -refresh=true -lock=true -state=$EnvironmentState -out=$EnvironmentPlan -var-file="$EnvironmentVars"
terraform apply -no-color -compact-warnings -auto-approve -lock=true -state=$EnvironmentState $EnvironmentPlan

Under borttagningsskriptet kan du lägga till destroy flaggan i din plangenerering för att ta bort befintliga resurser, som du ser i följande exempel:

terraform init
terraform plan -no-color -compact-warnings -destroy -refresh=true -lock=true -state=$EnvironmentState -out=$EnvironmentPlan -var-file="$EnvironmentVars"
terraform apply -no-color -compact-warnings -auto-approve -lock=true -state=$EnvironmentState $EnvironmentPlan

Slutligen, för att göra utdata från distributionen uppladdade och tillgängliga när du kommer åt din miljö via Azure CLI, omvandlar du utdataobjektet från Terraform till det ADE-angivna formatet via JQ-paketet. Ange värdet till miljövariabeln $ADE_OUTPUTS enligt följande exempel:

tfOutputs=$(terraform output -state=$EnvironmentState -json)
# Convert Terraform output format to ADE format.
tfOutputs=$(jq 'walk(if type == "object" then 
            if .type == "bool" then .type = "boolean" 
            elif .type == "list" then .type = "array" 
            elif .type == "map" then .type = "object" 
            elif .type == "set" then .type = "array" 
            elif (.type | type) == "array" then 
                if .type[0] == "tuple" then .type = "array" 
                elif .type[0] == "object" then .type = "object" 
                elif .type[0] == "set" then .type = "array" 
                else . 
                end 
            else . 
            end 
        else . 
        end)' <<< "$tfOutputs")

echo "{\"outputs\": $tfOutputs}" > $ADE_OUTPUTS

Skapa den anpassade avbildningen

Du kan skapa avbildningen med Hjälp av Docker CLI. Kontrollera att Docker-motorn är installerad på datorn. Navigera sedan till katalogen för din Dockerfile och kör följande kommando:

docker build . -t {YOUR_REGISTRY}.azurecr.io/{YOUR_REPOSITORY}:{YOUR_TAG}

Om du till exempel vill spara avbildningen under en lagringsplats i registret med namnet customImageoch ladda upp med taggversionen av 1.0.0kör du:

docker build . -t {YOUR_REGISTRY}.azurecr.io/customImage:1.0.0

Använda en standardcontaineravbildning som tillhandahålls av Pulumi

Pulumi-teamet tillhandahåller en fördefinierad avbildning för att komma igång, som du kan se i mappen Runner-Image . Den här avbildningen är offentligt tillgänglig på Pulumis Docker Hub som pulumi/azure-deployment-environments, så du kan använda den direkt från ADE-miljödefinitionerna.

Här är en exempelfil för environment.yaml som använder den fördefinierade avbildningen:

name: SampleDefinition
version: 1.0.0
summary: First Pulumi-Enabled Environment
description: Deploys a Storage Account with Pulumi
runner: pulumi/azure-deployment-environments:0.1.0
templatePath: Pulumi.yaml

Du hittar några exempel på miljödefinitioner i mappen Miljöer.

Skapa en anpassad avbildning

När du skapar en anpassad containeravbildning kan du anpassa dina distributioner så att de passar dina behov. Du kan skapa anpassade avbildningar baserat på Pulumi-standardbilderna och anpassa dem efter dina behov. När du har slutfört avbildningsanpassningen måste du skapa avbildningen och push-överföra den till containerregistret.

Följ dessa steg för att skapa en avbildning som konfigurerats för ADE:

1. Skapa en anpassad avbildning baserat på en standardbild.
2. Installera önskade paket.
3. Konfigurera åtgärdsgränssnittsskript.
4. Skapa åtgärdsgränssnittsskript som använder Pulumi CLI.

1. Skapa en anpassad avbildning baserat på en standardbild

Skapa en DockerFile som innehåller en FROM-instruktion som pekar på en standardbild som finns på Microsofts artefaktregister.

Här är ett exempel på FROM-instruktionen som refererar till standardkärnbilden:

FROM mcr.microsoft.com/deployment-environments/runners/core:latest

Den här instruktionen hämtar den senast publicerade kärnbilden och utgör grunden för din anpassade avbildning.

2. Installera nödvändiga paket

Du kan installera Pulumi CLI på en körbar plats så att den kan användas i distributions- och borttagningsskripten.

Här är ett exempel på den processen genom att installera den senaste versionen av Pulumi CLI:

RUN apk add curl
RUN curl -fsSL https://get.pulumi.com | sh
ENV PATH="${PATH}:/root/.pulumi/bin"

Beroende på vilket programmeringsspråk du tänker använda för Pulumi-program kan du behöva installera en eller flera motsvarande körningar. Python-körningen är redan tillgänglig i basavbildningen.

Här är ett exempel på hur du installerar Node.js och TypeScript:

# install node.js, npm, and typescript
RUN apk add nodejs npm
RUN npm install typescript -g

ADE-standardavbildningarna baseras på Azure CLI-avbildningen och har ADE CLI- och JQ-paketen förinstallerade. Du kan lära dig mer om Azure CLI och JQ-paketet.

Om du vill installera fler paket som du behöver i avbildningen använder du RUN-instruktionen.

Det finns fyra steg för att distribuera infrastruktur via Pulumi:

1. pulumi login – ansluta till tillståndslagringen, antingen i det lokala filsystemet eller i Pulumi Cloud
2. pulumi stack select – skapa eller välja den stack som ska användas för den specifika miljön
3. pulumi config set – skicka distributionsparametrar som Pulumi-konfigurationsvärden
4. pulumi up – kör distributionen för att skapa ny eller uppdatera befintlig infrastruktur i Azure

Under kärnavbildningens startpunkt hämtas alla befintliga lokala tillståndsfiler till containern och katalogen sparas under miljövariabeln $ADE_STORAGE. Kör följande kommandon för att få åtkomst till den befintliga tillståndsfilen:

mkdir -p $ADE_STORAGE
export PULUMI_CONFIG_PASSPHRASE=
pulumi login file://$ADE_STORAGE

Om du vill logga in på Pulumi Cloud i stället anger du din Pulumi-åtkomsttoken som en miljövariabel och kör följande kommandon:

export PULUMI_ACCESS_TOKEN=YOUR_PULUMI_ACCESS_TOKEN
pulumi login

Alla parametrar som anges för den aktuella miljön lagras under variabeln $ADE_OPERATION_PARAMETERS. Dessutom skickas det valda namnet på Azure-regionen och resursgruppen i ADE_ENVIRONMENT_LOCATION respektive ADE_RESOURCE_GROUP_NAME . Kör följande kommandon för att ställa in konfigurationen av Pulumi-stacken:

# Create or select the stack for the current environment
pulumi stack select $ADE_ENVIRONMENT_NAME --create

# Store configuration values in durable storage
export PULUMI_CONFIG_FILE=$ADE_STORAGE/Pulumi.$ADE_ENVIRONMENT_NAME.yaml

# Set the Pulumi stack config
pulumi config set azure-native:location $ADE_ENVIRONMENT_LOCATION --config-file $PULUMI_CONFIG_FILE
pulumi config set resource-group-name $ADE_RESOURCE_GROUP_NAME --config-file $PULUMI_CONFIG_FILE
echo "$ADE_OPERATION_PARAMETERS" | jq -r 'to_entries|.[]|[.key, .value] | @tsv' |
  while IFS=$'\t' read -r key value; do
    pulumi config set $key $value --config-file $PULUMI_CONFIG_FILE
  done

För att kunna använda ADE-behörigheter för att distribuera infrastruktur i din prenumeration måste skriptet dessutom använda ADE Managed Service Identity (MSI) när du etablerar infrastruktur med hjälp av Pulumi Azure Native- eller Azure Classic-providern. Om distributionen behöver särskilda behörigheter för att slutföra distributionen, till exempel särskilda roller, tilldelar du dessa behörigheter till den projektmiljötyps identitet som används för din miljödistribution. ADE anger relevanta miljövariabler, till exempel klient-, klient- och prenumerations-ID:t i kärnbildens startpunkt, så kör följande kommandon för att säkerställa att providern använder ADE MSI:

export ARM_USE_MSI=true
export ARM_CLIENT_ID=$ADE_CLIENT_ID
export ARM_TENANT_ID=$ADE_TENANT_ID
export ARM_SUBSCRIPTION_ID=$ADE_SUBSCRIPTION_ID

Nu kan du köra pulumi up kommandot för att köra distributionen:

pulumi up --refresh --yes --config-file $PULUMI_CONFIG_FILE

Under borttagningsskriptet destroy kan du i stället köra kommandot, som du ser i följande exempel:

pulumi destroy --refresh --yes --config-file $PULUMI_CONFIG_FILE

Slutligen, för att göra utdata från distributionen uppladdade och tillgängliga när du kommer åt din miljö via Azure CLI, omvandlar du utdataobjektet från Pulumi till det ADE-angivna formatet via JQ-paketet. Ange värdet till miljövariabeln $ADE_OUTPUTS enligt följande exempel:

stackout=$(pulumi stack output --json | jq -r 'to_entries|.[]|{(.key): {type: "string", value: (.value)}}')
echo "{\"outputs\": ${stackout:-{\}}}" > $ADE_OUTPUTS

Skapa den anpassade avbildningen

Du kan skapa avbildningen med Hjälp av Docker CLI. Kontrollera att Docker-motorn är installerad på datorn. Navigera sedan till katalogen för din Dockerfile och kör följande kommando:

docker build . -t {YOUR_REGISTRY}.azurecr.io/{YOUR_REPOSITORY}:{YOUR_TAG}

Om du till exempel vill spara avbildningen under en lagringsplats i registret med namnet customImageoch ladda upp med taggversionen av 1.0.0kör du:

docker build . -t {YOUR_REGISTRY}.azurecr.io/customImage:1.0.0

Gör den anpassade avbildningen tillgänglig för ADE

För att kunna använda anpassade avbildningar måste du lagra dem i ett containerregister. Du kan använda ett offentligt containerregister eller ett privat containerregister. Azure Container Registry (ACR) rekommenderas starkt, på grund av den snäva integreringen med ADE kan avbildningen publiceras utan att tillåta offentlig anonym pull-åtkomst. Du måste skapa din anpassade containeravbildning och skicka den till ett containerregister för att göra den tillgänglig för användning i ADE.

Det går också att lagra avbildningen i ett annat containerregister, till exempel Docker Hub, men i så fall måste den vara offentligt tillgänglig.

Varning

Om du lagrar containeravbildningen i ett register med anonym (oautentiserad) pull-åtkomst blir den offentligt tillgänglig. Gör inte det om bilden innehåller känslig information. Lagra den i stället i Azure Container Registry (ACR) med anonym pull-åtkomst inaktiverad.

Om du vill använda en anpassad avbildning som lagras i ACR måste du se till att ADE har rätt behörighet att komma åt avbildningen. När du skapar en ACR-instans är den säker som standard och tillåter endast autentiserade användare att få åtkomst.

Du kan använda Pulumi för att skapa ett Azure Container Registry och publicera avbildningen till det. Se exemplet Etablering/anpassad avbildning för ett fristående Pulumi-projekt som skapar alla nödvändiga resurser i ditt Azure-konto.

Välj lämplig flik för att lära dig mer om varje metod.

Privat register

Använda ett privat register med säker åtkomst

Som standard är åtkomst till att hämta eller skicka innehåll från ett Azure Container Registry endast tillgängligt för autentiserade användare. Du kan skydda åtkomsten till ACR ytterligare genom att begränsa åtkomsten från vissa nätverk och tilldela specifika roller.

Om du vill skapa en instans av ACR, som kan göras via Azure CLI, Azure Portal, PowerShell-kommandon med mera, följer du en av snabbstarterna.

Begränsa nätverksåtkomst

För att skydda nätverksåtkomsten till din ACR kan du begränsa åtkomsten till dina egna nätverk eller inaktivera åtkomsten till det offentliga nätverket helt. Om du begränsar nätverksåtkomsten måste du aktivera brandväggsfelet Tillåt betrodda Microsoft-tjänster att komma åt det här containerregistret.

Så här inaktiverar du åtkomst från offentliga nätverk:

1. Skapa en ACR-instans eller använd en befintlig.

2. I Azure Portal går du till den ACR som du vill konfigurera.

3. På den vänstra menyn går du till Inställningar och väljer Nätverk.

4. På sidan Nätverk går du till fliken Offentlig åtkomst och under Åtkomst till offentligt nätverk väljer du Inaktiverad.

   

5. Under Brandväggsfel kontrollerar du att Tillåt betrodda Microsoft-tjänster att komma åt det här containerregistret är markerat och välj sedan Spara.

   

Tilldela rollen AcrPull

När du skapar miljöer med hjälp av containeravbildningar används ADE-infrastrukturen, inklusive projekt och miljötyper. Varje projekt har en eller flera projektmiljötyper som behöver läsbehörighet till containeravbildningen som definierar den miljö som ska distribueras. Om du vill komma åt avbildningarna i din ACR på ett säkert sätt tilldelar du rollen AcrPull till varje projektmiljötyp.

Så här tilldelar du rollen AcrPull till projektmiljötypen:

1. I Azure Portal går du till den ACR som du vill konfigurera.

2. Välj Åtkomstkontroll (IAM) på den vänstra menyn.

3. Välj Lägg till>Lägg till rolltilldelning.

4. Tilldela följande roll. Läs mer om att tilldela roller i Tilldela Azure-roller via Azure Portal.

   Inställning	Värde
   Roll	Välj AcrPull.
   Tilldela åtkomst till	Välj Användare, grupp eller tjänstens huvudnamn.
   Medlemmar	Ange namnet på den projektmiljötyp som behöver komma åt avbildningen i containern.

   Projektmiljötypen visas som i följande exempel:

   

I den här konfigurationen använder ADE den hanterade identiteten för PET, oavsett om systemet har tilldelats eller användaren har tilldelats.

Dricks

Den här rolltilldelningen måste göras för varje projektmiljötyp. Det kan automatiseras via Azure CLI.

När du är redo att skicka avbildningen till registret kör du följande kommando:

docker push {YOUR_REGISTRY}.azurecr.io/{YOUR_IMAGE_LOCATION}:{YOUR_TAG}

Offentligt register

Använda ett offentligt register med anonym pull

Om du vill konfigurera registret så att anonym avbildningshämtning är aktiverat kör du följande kommandon i Azure CLI:

az login
az acr login -n {YOUR_REGISTRY}
az acr update -n {YOUR_REGISTRY} --public-network-enabled true
az acr update -n {YOUR_REGISTRY} --anonymous-pull-enabled true

När du är redo att skicka avbildningen till registret kör du följande kommando:

docker push {YOUR_REGISTRY}.azurecr.io/{YOUR_IMAGE_LOCATION}:{YOUR_TAG}

Ansluta avbildningen till din miljödefinition

När du redigerar miljödefinitioner för att använda din anpassade avbildning i distributionen runner redigerar du egenskapen i manifestfilen (environment.yaml eller manifest.yaml).

runner: "{YOUR_REGISTRY}.azurecr.io/{YOUR_REPOSITORY}:{YOUR_TAG}"

Mer information om hur du skapar miljödefinitioner som använder ADE-containeravbildningarna för att distribuera dina Azure-resurser finns i Lägga till och konfigurera en miljödefinition.

Relaterat innehåll

• Referens för ADE CLI Custom Runner Image
• Referens för ADE CLI-variabler

• Lagringsplatsen azure-deployment-environments i Pulumi