Konfigurera containeravbildning för att köra distributioner

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 Azure Deployment Environments (ADE).

I den här artikeln får du lära dig hur du skapar anpassade Terraform-containeravbildningar för att distribuera dina miljödefinitioner i 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 Azure Deployment Environments (ADE). Du lär dig hur du använder en exempelbild som tillhandahålls av Pulumi eller hur du konfigurerar en anpassad avbildning för att etablera infrastruktur med hjälp av IaC-ramverket (Infrastruktur som kod).

ADE stöder en utökningsmodell som gör att du kan skapa anpassade avbildningar som du kan använda i dina miljödefinitioner. Om du vill använda den här utökningsmodellen skapar du egna anpassade avbildningar och lagrar dem i ett containerregister som Azure Container Registry (ACR) eller Docker Hub. Du kan sedan referera till dessa avbildningar i dina miljödefinitioner för att distribuera dina miljöer.

En miljödefinition består av minst två filer: en mallfil, till exempel azuredeploy.json eller main.bicep, och en manifestfil med namnet environment.yaml. ADE använder containrar för att distribuera miljödefinitioner.

ADE-teamet tillhandahåller ett urval av bilder för att komma igång, inklusive en kärnbild och en Azure Resource Manager(ARM)-Bicep-avbildning. Du kan komma åt dessa exempelbilder i mappen Runner-Images .

En miljödefinition består av minst två filer: en mallfil, till exempel main.tf, och en manifestfil med namnet environment.yaml. Du använder en container för att distribuera miljödefinitioner som använder Terraform.

En miljödefinition består av minst två filer: en Pulumi-projektfil, Pulumi.yaml och en manifestfil med namnet environment.yaml. Det kan också innehålla ett användarprogram som skrivits på önskat programmeringsspråk: C#, TypeScript, Python osv. ADE använder containrar för att distribuera miljödefinitioner.

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 exempelcontaineravbildning För enkla scenarier använder du arm-Bicep-exempelcontaineravbildningen som tillhandahålls av ADE.
• Skapa en anpassad containeravbildning För mer komplexa scenarier skapar du en anpassad containeravbildning som uppfyller dina specifika krav.

De viktigaste stegen du följer när du använder en containeravbildning är:

1. Välj den bildtyp som du vill använda: en exempelbild eller en anpassad avbildning.
   • Om du använder en anpassad avbildning börjar du med en exempelbild och anpassar den efter dina behov.
2. Skapa avbildningen.
3. Ladda upp avbildningen till ett privat register eller ett offentligt register.
4. Konfigurera åtkomst till registret.
   • Konfigurera anonym pull för ett offentligt register.
   • Ge DevCenter ACR-behörigheter för ett privat register.
5. Lägg till din avbildningsplats i parametern runner i din miljödefinition
6. Distribuera miljöer som använder din anpassade avbildning.

Det första steget i processen är att välja vilken typ av bild du vill använda. Välj motsvarande flik för att se processen.

Använda en exempelcontaineravbildning

Använda en exempelcontaineravbildning

ADE stöder ARM och Bicep utan att kräva någon 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 exempelcontaineravbildningen ARM-Bicep 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 exempelbilden som publicerats på Microsofts artefaktregister använder du respektive identifierare runner.

I följande exempel visas en runner som refererar till ARM-Bicep-containeravbildningen exempel:

    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 Bicep-exempelcontaineravbildningen i ADE-exempellagringsplatsen 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.

Använda en exempelcontaineravbildning från 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

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å ADE-exempelbilderna.

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.

Du kan också förgrena lagringsplatsen Genom att använda ADE:s utökningsmodell med Terraform för att skapa och push-överföra Terraform-avbildningen till en angivet ACR.

Du skapar anpassade avbildningar med hjälp av ADE-exempelavbildningarna som bas med ADE CLI, som är förinstallerat på exempelavbildningarna. 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 exempelbild.
2. Installera önskade paket.
3. Konfigurera åtgärdsgränssnittsskript.
4. Skapa åtgärdsgränssnittsskript för att distribuera ARM- eller Bicep-mallar.

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

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

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

1. Skapa en anpassad avbildning baserat på en exempelbild.
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 exempelbild

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

Här är ett exempel på FROM-instruktion som refererar till exempelkä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

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.

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-exempelavbildningarna 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 exempelbilderna 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

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:

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

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

Bygga en avbildning

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}

Skapa en containeravbildning med ett skript

I stället för att skapa din anpassade avbildning och push-överföra den till ett containerregister själv kan du använda ett skript för att skapa och push-överföra den till ett angivet containerregister.

Microsoft tillhandahåller ett snabbstartsskript som hjälper dig att skapa din anpassade avbildning och skicka den till ett register. Skriptet skapar avbildningen och skickar den till ett angivet Azure Container Registry (ACR) under lagringsplatsen ade och taggen latest.

Om du vill använda skriptet måste du:

1. Skapa en Dockerfile- och skriptmapp för att stödja utökningsmodellen för ADE.
2. Ange ett registernamn och en katalog för din anpassade avbildning.
3. Installera Azure CLI och Docker Desktop och i path-variablerna.
4. Låt Docker Desktop köras.
5. Har behörighet att skicka till det angivna registret.

Du kan visa skriptet här.

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}'

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