Konfigurieren des Containerimages zum Ausführen von Bereitstellungen

In diesem Artikel erfahren Sie, wie Sie benutzerdefinierte Bicep-Containerimages erstellen, um Ihre Umgebungsdefinitionen in Azure Deployment Environments (ADE) bereitzustellen.

In diesem Artikel erfahren Sie, wie Sie benutzerdefinierte Terraform-Containerimages erstellen, um Ihre Umgebungsdefinitionen in Azure Deployment Environments (ADE) bereitzustellen. Sie erfahren, wie Sie ein benutzerdefiniertes Image für die Bereitstellung von Infrastruktur mithilfe des Terraform-IaC-Frameworks (Infrastructure-as-Code) konfigurieren.

In diesem Artikel erfahren Sie, wie Sie Pulumi für Bereitstellungen in Azure Deployment Environments (ADE) verwenden. Sie erfahren, wie Sie ein einfaches Image verwenden, das von Pulumi bereitgestellt wird, oder wie Sie ein benutzerdefiniertes Image für die Bereitstellung einer Infrastruktur mithilfe des Pulumi-IaC-Frameworks (Infrastructure-as-Code) bereitstellen.

ADE unterstützt ein Erweiterbarkeitsmodell, mit dem Sie benutzerdefinierte Images erstellen können, die Sie in Ihren Umgebungsdefinitionen verwenden können. Um dieses Erweiterbarkeitsmodell zu verwenden, erstellen Sie eigene benutzerdefinierte Images, und speichern Sie sie in einer Containerregistrierung wie Azure Container Registry (ACR) oder Docker Hub. Anschließend können Sie in Ihren Umgebungsdefinitionen auf diese Images verweisen, um Ihre Umgebungen bereitzustellen.

Eine Umgebungsdefinition umfasst mindestens zwei Dateien: eine Vorlagendatei, z. B. azuredeploy.json oder main.bicep, und eine Manifestdatei namens environment.yaml. ADE verwendet Container zum Bereitstellen von Umgebungsdefinitionen.

Das ADE-Team bietet eine Auswahl an Images für den Einstieg, einschließlich eines Kernimages und eines ARM-Bicep-Images (Azure Resource Manager). Sie können auf diese Beispielimages im Ordner Runner-Images zugreifen.

Eine Umgebungsdefinition umfasst mindestens zwei Dateien: eine Vorlagendatei, z. B. main.tf, und eine Manifestdatei namens environment.yaml. Sie verwenden einen Container, um die Umgebungsdefinition bereitzustellen, die Terraform verwendet.

Eine Umgebungsdefinition umfasst mindestens zwei Dateien: eine Pulumi-Projektdatei, Pulumi.yaml, und eine Manifestdatei mit dem Namen environment.yaml. Sie kann auch ein Benutzerprogramm enthalten, das in Ihrer bevorzugten Programmiersprache geschrieben wurde: C#, TypeScript, Python usw. ADE verwendet Container zum Bereitstellen von Umgebungsdefinitionen.

Voraussetzungen

• Ein Azure-Konto mit einem aktiven Abonnement. Sie können kostenlos ein Konto erstellen.
• Azure Deployment Environments, die in Ihrem Azure-Abonnement eingerichtet sind.
  • Befolgen Sie zum Einrichten von ADE die Schnellstartanleitung: Konfigurieren von Azure-Bereitstellungsumgebungen.

Verwenden von Containerimages mit ADE

Sie können einen der folgenden Ansätze verwenden, um Containerimages mit ADE zu verwenden:

• Beispielcontainerimage verwenden: Verwenden Sie für einfache Szenarien das ARM-Bicep-Beispielcontainerimage, das von ADE bereitgestellt wird.
• Benutzerdefiniertes Containerimage erstellen: Erstellen Sie für komplexere Szenarien ein benutzerdefiniertes Containerimage, das Ihren spezifischen Anforderungen entspricht.

Dies sind die wichtigsten Schritte, die Sie beim Verwenden eines Containerimages ausführen werden:

1. Wählen Sie den gewünschten Imagetyp aus: ein Beispielimage oder ein benutzerdefiniertes Image.
   • Wenn Sie ein benutzerdefiniertes Image verwenden, beginnen Sie mit einem Beispielimage, und passen Sie es dann an Ihre Anforderungen an.
2. Erstellen des Images.
3. Laden Sie das Image in eine private oder eine öffentliche Registrierung hoch.
4. Konfigurieren Sie den Zugriff auf die Registrierung.
   • Konfigurieren Sie für eine öffentliche Registrierung anonymen Pull.
   • Erteilen Sie für eine private Registrierung dem DevCenter ACR-Berechtigungen.
5. Fügen Sie den Imagespeicherort dem runner-Parameter in Ihrer Umgebungsdefinition hinzu.
6. Stellen Sie Umgebungen bereit, die Ihr benutzerdefiniertes Image verwenden.

Der erste Schritt im Prozess besteht darin, den Typ des zu verwendenden Images auszuwählen. Wählen Sie die entsprechende Registerkarte aus, um den Prozess anzuzeigen.

Verwenden eines Beispielcontainerimages

Verwenden eines Beispielcontainerimages

ADE unterstützt ARM und Bicep ohne zusätzliche Konfiguration. Sie erstellen eine Umgebungsdefinition, die Azure-Ressourcen für eine Bereitstellungsumgebung bereitstellt, indem Sie Ihrem Katalog die Vorlagendateien (z. B. azuredeploy.json und environment.yaml) hinzufügen. ADE verwendet dann das ARM-Bicep-Beispielcontainerimage, um die Bereitstellungsumgebung zu erstellen.

In der Datei environment.yaml gibt die runner-Eigenschaft den Speicherort des Containerimages an, das Sie verwenden möchten. Um das Beispielimage zu verwenden, das in der Microsoft-Artefaktregistrierung veröffentlicht wurde, verwenden Sie die entsprechenden Bezeichner für runner.

Das folgende Beispiel zeigt einen runner, der auf das ARM-Bicep-Beispielcontainerimage verweist:

    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

Sie können das Bicep-Beispielcontainerimage im ADE-Beispielrepository unter dem Ordner für Runner-Images für das ARM-Bicep-Image sehen.

Weitere Informationen zum Erstellen von Umgebungsdefinitionen, die die ADE-Containerimages verwenden, um Ihre Azure-Ressourcen bereitzustellen, finden Sie unter Hinzufügen und Konfigurieren einer Umgebungsdefinition.

Verwenden eines Beispielcontainerimages, das von Pulumi bereitgestellt wird

Das Pulumi-Team bietet ein vorgefertigtes Bild für die ersten Schritte, das Sie im Ordner Runner-Image sehen können. Dieses Image ist im Docker Hub von Pulumi öffentlich verfügbar als pulumi/azure-deployment-environments, sodass Sie es direkt aus Ihren ADE-Umgebungsdefinitionen verwenden können.

Hier ist eine environment.yaml-Beispieldatei, die das vorgefertigte Image verwendet:

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

Im Ordner Umgebungen finden Sie einige Beispielumgebungsdefinitionen.

Erstellen eines benutzerdefinierten Images

Erstellen eines benutzerdefinierten Images

Durch das Erstellen eines benutzerdefinierten Containerimages können Sie Ihre Bereitstellungen an Ihre Anforderungen anpassen. Sie können benutzerdefinierte Images basierend auf den ADE-Beispielimages erstellen.

Nachdem Sie die Imageanpassung abgeschlossen haben, müssen Sie das Image kompilieren und in die Containerregistrierung pushen.

Sie können das Image manuell erstellen und pushen oder ein von Microsoft bereitgestelltes Skript verwenden, um den Prozess zu automatisieren.

Alternativ können Sie das Repository Nutzen des Erweiterbarkeitsmodells von ADE mit Terraform forken, um das Terraform-Image zu erstellen und es an eine bereitgestellte ACR zu pushen.

Sie erstellen benutzerdefinierte Images mithilfe der ADE-Beispielimages als Basis mit der ADE CLI, die auf den Beispielimages vorinstalliert ist. Weitere Informationen zur ADE CLI finden Sie in der Referenz zur CLI für benutzerdefinierte Runner-Images.

In diesem Beispiel erfahren Sie, wie Sie ein Docker-Image erstellen, um ADE-Bereitstellungen zu nutzen und auf die ADE CLI zuzugreifen, indem Sie als Grundlage für Ihr Image eines der erstellten ADE-Images verwenden.

Führen Sie die folgenden Schritte aus, um ein für ADE konfiguriertes Image zu erstellen:

1. Erstellen Sie ein benutzerdefiniertes Image auf Grundlage eines Beispielimages.
2. Installieren Sie die gewünschten Pakete.
3. Konfigurieren Sie Shellskripts für Vorgänge.
4. Erstellen Sie Shellskripts für Vorgänge zum Bereitstellen von ARM- oder Bicep-Vorlagen.

Führen Sie die folgenden Schritte aus, um ein für ADE konfiguriertes Image zu erstellen:

1. Erstellen Sie ein benutzerdefiniertes Image auf Grundlage eines Beispielimages.
2. Installieren Sie die gewünschten Pakete.
3. Konfigurieren Sie Shellskripts für Vorgänge.
4. Erstellen Sie Shellskripts für Vorgänge, die die Terraform-CLI verwenden.

Führen Sie die folgenden Schritte aus, um ein für ADE konfiguriertes Image zu erstellen:

1. Erstellen Sie ein benutzerdefiniertes Image auf Grundlage eines Beispielimages.
2. Installieren Sie die gewünschten Pakete.
3. Konfigurieren Sie Shellskripts für Vorgänge.
4. Erstellen Sie Shellskripts für Vorgänge, die die Pulumi-CLI verwenden.

1. Erstellen eines benutzerdefinierten Images auf Grundlage eines Beispielimages

Erstellen Sie eine Dockerfile mit einer FROM-Anweisung, die auf ein Beispielimage zeigt, das in der Microsoft-Artefaktregistrierung gehostet wird.

Hier ist eine FROM-Beispielanweisung, die auf das Beispielkernimage verweist:

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

Diese Anweisung ruft das zuletzt veröffentlichte Kernimage ab und macht es zur Grundlage für Ihr benutzerdefiniertes Image.

2. Installieren der erforderlichen Pakete

In diesem Schritt installieren Sie alle Pakete, die Sie in Ihrem Image benötigen, einschließlich Bicep. Sie können das Bicep-Paket mit der Azure-Befehlszeilenschnittstelle mithilfe der RUN-Anweisung installieren, wie im folgenden Beispiel gezeigt:

RUN az bicep install

In diesem Schritt installieren Sie alle Pakete, die Sie in Ihrem Image benötigen, einschließlich Terraform. Sie können die Terraform CLI an einem ausführbaren Speicherort installieren, damit sie in Ihren Bereitstellungs- und Löschskripts verwendet werden kann.

Das folgende Beispiel veranschaulicht diesen Prozess für die Installation von Version 1.7.5 der 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

Tipp

Sie können die Download-URL für Ihre bevorzugte Version der Terraform-CLI von Hashicorp-Releases erhalten.

Sie können die Pulumi CLI an einem ausführbaren Speicherort installieren, damit sie in Ihren Bereitstellungs- und Löschskripts verwendet werden kann.

Hier ist ein Beispiel für diesen Prozess, der die neueste Version der Pulumi CLI installiert:

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

Je nachdem, welche Programmiersprache Sie für Pulumi-Programme verwenden möchten, müssen Sie möglicherweise eine oder mehrere entsprechende Laufzeiten installieren. Die Python-Laufzeit ist bereits im Basisimage verfügbar.

Hier ist ein Beispiel für die Installation von Node.js und TypeScript:

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

Die ADE-Beispielimages basieren auf dem Azure CLI-Image, in dem die ADE CLI- und JQ-Pakete bereits vorinstalliert sind. Erfahren Sie mehr über die Azure-Befehlszeilenschnittstelle und das JQ-Paket.

Verwenden Sie die RUN-Anweisung, um weitere Pakete zu installieren, die Sie in Ihrem Image benötigen.

3. Konfigurieren der Shellskripts für Vorgänge

Innerhalb der Beispielimages werden Vorgänge basierend auf dem Vorgangsnamen bestimmt und ausgeführt. Derzeit werden die beiden Vorgangsnamen deploy und delete unterstützt.

Wenn Sie Ihr benutzerdefiniertes Image so einrichten möchten, dass diese Struktur verwendet wird, geben Sie einen Ordner auf der Ebene Ihres Dockerfiles scripts sowie die beiden Dateien deploy.sh und delete.sh an. Das Shellskript für die Bereitstellung wird ausgeführt, wenn Ihre Umgebung erstellt oder erneut bereitgestellt wird, während das Shellskript für die Löschung ausgeführt wird, wenn Ihre Umgebung gelöscht wird. Beispiele für Shellskripts finden Sie im Repository im Ordner Runner-Images für das ARM-Bicep-Image.

Um sicherzustellen, dass diese Shellskripts ausführbar sind, fügen Sie Ihrem Dockerfile die folgenden Zeilen hinzu:

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

4. Erstellen von Shellskripts für Vorgänge zum Bereitstellen von ARM- oder Bicep-Vorlagen

Um sicherzustellen, dass Sie eine ARM- oder Bicep-Infrastruktur über ADE erfolgreich bereitstellen können, ist Folgendes erforderlich:

1. Konvertieren von ADE-Parametern in von ARM akzeptierte Parameter
2. Auflösen verknüpfter Vorlagen, wenn diese in der Bereitstellung verwendet werden
3. Verwenden einer verwalteten Identität mit erhöhten Rechten zum Ausführen der Bereitstellung

Während des Einstiegspunkts des Kernimages werden alle Parameter, die für die aktuelle Umgebung festgelegt wurden, in der Variable $ADE_OPERATION_PARAMETERS gespeichert. Um sie in von ARM akzeptierte Parameter zu konvertieren, können Sie den folgenden Befehl mit JQ ausführen:

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

Um alle verknüpften Vorlagen in einer ARM-JSON-Vorlage aufzulösen, können Sie als Nächstes die Hauptvorlagendatei dekompilieren. Damit werden alle lokalen Infrastrukturdateien aufgelöst, die in vielen Bicep-Modulen verwendet werden. Erstellen Sie diese Module dann erneut in einer einzelnen ARM-Vorlage mit den verknüpften Vorlagen, die in die ARM-Hauptvorlage als geschachtelte Vorlagen eingebettet sind. Dieser Schritt ist nur während des Bereitstellungsvorgangs erforderlich. Die Hauptvorlagendatei kann durch Festlegen von $ADE_TEMPLATE_FILE während des Einstiegspunkts des Kernimages angegeben werden. Sie sollten diese Variable mit der erneut kompilierten Vorlagendatei zurücksetzen. Siehe folgendes Beispiel:

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

Um die Berechtigungen bereitzustellen, die für eine Bereitstellung benötigt werden, um die Bereitstellung und Löschung von Ressourcen innerhalb des Abonnements auszuführen, verwenden Sie eine verwaltete Identität mit erhöhten Rechten, die dem Typ der ADE-Projektumgebung zugeordnet ist. Wenn für den Abschluss Ihrer Bereitstellung spezielle Berechtigungen erforderlich sind (z. B. bestimmte Rollen), weisen Sie diese Rollen der Identität des Projektumgebungstyps zu. Manchmal ist die verwaltete Identität nicht sofort beim Einstieg in den Container verfügbar. Sie können den Vorgang dann wiederholen, bis die Anmeldung erfolgreich ist.

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

Um mit der Bereitstellung der ARM- oder Bicep-Vorlagen zu beginnen, führen Sie den Befehl az deployment group create aus. Wenn Sie diesen Befehl innerhalb des Containers ausführen, wählen Sie einen Bereitstellungsnamen aus, der keine früheren Bereitstellungen überschreibt. Verwenden Sie außerdem die Flags --no-prompt true und --only-show-errors, um sicherzustellen, dass die Bereitstellung bei Warnungen oder beim Warten auf Benutzereingaben nicht zu Fehlern führt, wie im folgenden Beispiel gezeigt:

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

Führen Sie zum Löschen einer Umgebung eine Bereitstellung im Modus „Complete“ aus, und stellen Sie eine leere ARM-Vorlage bereit, die alle Ressourcen innerhalb der angegebenen ADE-Ressourcengruppe entfernt, wie im folgenden Beispiel gezeigt:

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"

Sie können den Bereitstellungsstatus und die Details überprüfen, indem Sie die folgenden Befehle ausführen. ADE verwendet einige spezielle Funktionen, um mehr Kontext basierend auf den Bereitstellungsdetails zu lesen und bereitzustellen, die Sie auch im Ordner Runner-Images finden. Eine einfache Implementierung könnte wie folgt aussehen:

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

Um zum Schluss die Ausgaben Ihrer Bereitstellung anzuzeigen und an ADE zu übergeben, damit sie über die Azure-Befehlszeilenschnittstelle zugänglich sind, können Sie die folgenden Befehle ausführen:

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. Erstellen von Shellskripts für Vorgänge, die die Terraform-CLI verwenden

Die Bereitstellung der Infrastruktur über Terraform umfasst drei Schritte:

1. terraform init initialisiert die Terraform CLI, um Aktionen im Arbeitsverzeichnis auszuführen.
2. terraform plan entwickelt einen Plan basierend auf den eingehenden Terraform-Infrastrukturdateien und -variablen sowie vorhandenen Zustandsdateien und entwickelt die zum Erstellen oder Aktualisieren der in den TF-Dateien angegebenen Infrastruktur erforderlichen Schritte.
3. terraform apply wendet den Plan an, um eine neue Infrastruktur in Azure zu erstellen oder eine vorhandene zu aktualisieren.

Während des Einstiegspunkts des Kernimages werden alle vorhandenen Zustandsdateien in den Container und das unter der Umgebungsvariable $ADE_STORAGE gespeicherte Verzeichnis gepullt. Darüber hinaus werden alle Parameter, die für die aktuelle Umgebung festgelegt wurden, in der Variable $ADE_OPERATION_PARAMETERS gespeichert. Um auf die vorhandene Zustandsdatei zuzugreifen und die Variablen in der Datei .tfvars.json festzulegen, führen Sie die folgenden Befehle aus:

EnvironmentState="$ADE_STORAGE/environment.tfstate"
EnvironmentPlan="/environment.tfplan"
EnvironmentVars="/environment.tfvars.json"

echo "$ADE_OPERATION_PARAMETERS" > $EnvironmentVars

Darüber hinaus muss Ihr Skript, um die ADE-Berechtigungen zum Bereitstellen der Infrastruktur in Ihrem Abonnement zu nutzen, die verwaltete Dienstidentität (Managed Service Identity, MSI) beim Bereitstellen der Infrastruktur mithilfe des Terraform AzureRM-Anbieters verwenden. Wenn für den Abschluss Ihrer Bereitstellung spezielle Berechtigungen erforderlich sind (z. B. bestimmte Rollen), weisen Sie diese Berechtigungen der Identität des Projektumgebungstyps zu, der für die Bereitstellung Ihrer Umgebung verwendet wird. ADE legt die relevanten Umgebungsvariablen (z. B. Client-, Mandanten- und Abonnement-IDs) innerhalb des Einstiegspunkts des Kernimages fest. Führen Sie daher die folgenden Befehle aus, um sicherzustellen, dass der Anbieter die MSI von ADE verwendet:

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

Wenn Sie innerhalb Ihrer Vorlage auf andere Variablen verweisen möchten, die nicht in den Parametern Ihrer Umgebung angegeben sind, legen Sie Umgebungsvariablen mithilfe des Präfixes TF_VAR fest. Eine Liste der bereitgestellten ADE-Umgebungsvariablen finden Sie unter Referenz der CLI-Variablen von Azure Deployment Environments. Ein mögliches Beispiel für diese Befehle:

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

Nun können Sie die oben aufgeführten Schritte ausführen, um die Terraform CLI zu initialisieren, einen Plan für die Bereitstellung der Infrastruktur zu generieren und diesen in Ihrem Bereitstellungsskript anzuwenden:

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

Sie können wie im folgenden Beispiel gezeigt im Löschskript das Flag destroy für die Plangenerierung hinzufügen, um die vorhandenen Ressourcen zu löschen:

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

Um die Ausgaben Ihrer Bereitstellung hochzuladen und über die Azure-Befehlszeilenschnittstelle beim Zugriff auf Ihre Umgebung zugänglich zu machen, transformieren Sie das Ausgabeobjekt von Terraform über das JQ-Paket in das ADE-Format. Legen Sie den Wert auf die Umgebungsvariable „$ADE_OUTPUTS“ fest, wie im folgenden Beispiel gezeigt:

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

Es gibt vier Schritte zur Bereitstellung der Infrastruktur über Pulumi:

1. pulumi login – Herstellen einer Verbindung mit dem Zustandsspeicher, entweder im lokalen Dateisystem oder in Pulumi Cloud
2. pulumi stack select – Erstellen oder Auswählen des Stapels, der für die jeweilige Umgebung verwendet werden soll
3. pulumi config set – Übergeben von Bereitstellungsparametern als Pulumi-Konfigurationswerte
4. pulumi up – Anwendung der Bereitstellung, um eine neue Infrastruktur in Azure zu erstellen oder eine vorhandene zu aktualisieren

Während des Einstiegspunkts des Kernimages werden alle vorhandenen lokalen Zustandsdateien in den Container und das unter der Umgebungsvariable $ADE_STORAGE gespeicherte Verzeichnis gepullt. Um auf die vorhandene Statusdatei zuzugreifen, führen Sie die folgenden Befehle aus:

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

Wenn Sie sich stattdessen bei Pulumi Cloud anmelden möchten, legen Sie Ihr Pulumi-Zugriffstoken als Umgebungsvariable fest, und führen Sie die folgenden Befehle aus:

export PULUMI_ACCESS_TOKEN=YOUR_PULUMI_ACCESS_TOKEN
pulumi login

Alle Parameter, die für die aktuelle Umgebung festgelegt wurden, werden in der Variable $ADE_OPERATION_PARAMETERS gespeichert. Darüber hinaus werden der ausgewählte Azure-Region- und Ressourcengruppenname in ADE_ENVIRONMENT_LOCATION bzw ADE_RESOURCE_GROUP_NAME übergeben. Führen Sie zum Festlegen der Pulumi-Stapelkonfiguration die folgenden Befehle aus:

# 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

Darüber hinaus muss Ihr Skript, um die ADE-Berechtigungen zum Bereitstellen der Infrastruktur in Ihrem Abonnement zu nutzen, die ADI verwaltete Dienstidentität (Managed Service Identity, MSI) beim Bereitstellen der Infrastruktur mithilfe des Pulumi Azure Native oder Azure Classic-Anbieters verwenden. Wenn für den Abschluss Ihrer Bereitstellung spezielle Berechtigungen erforderlich sind (z. B. bestimmte Rollen), weisen Sie diese Berechtigungen der Identität des Projektumgebungstyps zu, der für die Bereitstellung Ihrer Umgebung verwendet wird. ADE legt die relevanten Umgebungsvariablen (z. B. Client-, Mandanten- und Abonnement-IDs) innerhalb des Einstiegspunkts des Kernimages fest. Führen Sie daher die folgenden Befehle aus, um sicherzustellen, dass der Anbieter die MSI von ADE verwendet:

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

Jetzt können Sie den pulumi up Befehl ausführen, um die Bereitstellung auszuführen:

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

Während des Löschskripts können Sie stattdessen den destroy Befehl ausführen, wie im folgenden Beispiel gezeigt:

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

Um die Ausgaben Ihrer Bereitstellung hochzuladen und über die Azure CLI beim Zugriff auf Ihre Umgebung zugänglich zu machen, transformieren Sie das Ausgabeobjekt von Pulumi über das JQ-Paket in das ADE-Format. Legen Sie den Wert auf die Umgebungsvariable „$ADE_OUTPUTS“ fest, wie im folgenden Beispiel gezeigt:

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

Erstellen eines Images

Sie können Ihr Image mithilfe der Docker-CLI erstellen. Stellen Sie sicher, dass das Docker-Modul auf Ihrem Computer installiert ist. Navigieren Sie dann zum Verzeichnis Ihres Dockerfiles, und führen Sie den folgenden Befehl aus:

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

Wenn Sie Ihr Image beispielsweise in einem Repository in Ihrer Registrierung mit dem Namen customImage speichern und mit der Tagversion 1.0.0 hochladen möchten, führen Sie Folgendes aus:

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

Verfügbarmachen des benutzerdefinierten Images für ADE

Um benutzerdefinierte Images verwenden zu können, müssen Sie sie in einer Containerregistrierung speichern. Sie können eine öffentliche oder eine private Containerregistrierung verwenden. Azure Container Registry (ACR) wird dringend empfohlen. Aufgrund der engen Verzahnung mit ADE kann das Image veröffentlicht werden, ohne den öffentlichen, anonymen Pullzugriff zuzulassen. Sie müssen Ihr benutzerdefiniertes Containerimage erstellen und an eine Containerregistrierung senden, um es für die Verwendung in ADE verfügbar zu machen.

Es ist auch möglich, das Image in einer anderen Containerregistrierung wie Docker Hub zu speichern, aber in diesem Fall muss es öffentlich zugänglich sein.

Achtung

Wenn Sie Ihr Containerimage in einer Registrierung mit anonymem (nicht authentifiziertem) Pullzugriff speichern, ist es öffentlich zugänglich. Tun Sie das nicht, wenn Ihr Image vertrauliche Informationen enthält. Speichern Sie es stattdessen in Azure Container Registry (ACR) mit deaktiviertem anonymen Pullzugriff.

Um ein benutzerdefiniertes Image zu verwenden, das in ACR gespeichert ist, müssen Sie sicherstellen, dass ADE über entsprechende Berechtigungen für den Zugriff auf Ihr Image verfügt. Wenn Sie eine ACR-Instanz erstellen, ist sie standardmäßig geschützt und ermöglicht nur authentifizierten Benutzern den Zugriff.

Sie können Pulumi verwenden, um eine Azure Container Registry zu erstellen und Ihr Image darin zu veröffentlichen. Verweisen Sie auf das Bereitstellungs-/benutzerdefinierte Image für ein eigenständiges Pulumi-Projekt, das alle erforderlichen Ressourcen in Ihrem Azure-Konto erstellt.

Wählen Sie die entsprechende Registerkarte aus, um mehr über die einzelnen Ansätze zu erfahren.

Private Registrierung

Verwenden einer privaten Registrierung mit gesichertem Zugriff

Standardmäßig ist der Zugriff auf Pull- oder Pushinhalte aus einer Azure Container Registry-Instanz nur für authentifizierte Benutzer möglich. Sie können den Zugriff auf die ACR weiter schützen, indem Sie den Zugriff von bestimmten Netzwerken einschränken und bestimmte Rollen zuweisen.

Um eine ACR-Instanz zu erstellen, was über die Azure CLI, das Azure-Portal, PowerShell-Befehle und vieles mehr möglich ist, befolgen Sie eine der Schnellstartanleitungen.

Netzwerkzugriff einschränken

Um den Netzwerkzugriff auf ACR zu schützen, können Sie den Zugriff auf Ihre eigenen Netzwerke einschränken oder den Zugriff auf öffentliche Netzwerke vollständig deaktivieren. Wenn Sie den Netzwerkzugriff einschränken, müssen Sie die Firewallausnahme Vertrauenswürdigen Microsoft-Diensten Zugriff auf diese Containerregistrierung gestatten aktivieren.

So deaktivieren Sie den Zugriff von öffentlichen Netzwerken:

1. Erstellen Sie eine ACR-Instanz, oder verwenden Sie eine vorhandene Instanz.

2. Navigieren Sie im Azure-Portal zu der ACR-Instanz, die Sie konfigurieren möchten.

3. Wählen Sie im linken Menü unter Einstellungen die Option Netzwerk aus.

4. Wählen Sie auf der Seite „Netzwerk“ auf der Registerkarte Öffentlicher Zugriff unter Öffentlicher Netzwerkzugriff die Option Deaktiviert aus.

   

5. Überprüfen Sie unter Firewallausnahme, ob Vertrauenswürdigen Microsoft-Diensten Zugriff auf diese Containerregistrierung gestatten aktiviert ist, und wählen Sie dann Speichern aus.

   

Zuweisen der AcrPull-Rolle

Das Erstellen von Umgebungen mithilfe von Containerimages verwendet die ADE-Infrastruktur, einschließlich Projekten und Umgebungstypen. Jedes Projekt verfügt über einen oder mehrere Projektumgebungstypen, die Lesezugriff auf das Containerimage benötigen, das die bereitzustellende Umgebung definiert. Um sicher auf die Images in Ihrer ACR zuzugreifen, weisen Sie die AcrPull-Rolle jedem Projektumgebungstyp zu.

So weisen Sie die AcrPull-Rolle dem Projektumgebungstyp zu:

1. Navigieren Sie im Azure-Portal zu der ACR-Instanz, die Sie konfigurieren möchten.

2. Wählen Sie im linken Menü Zugriffssteuerung (IAM) aus.

3. Wählen Sie Hinzufügen>Rollenzuweisung hinzufügen.

4. Weisen Sie die folgende Rolle zu. Ausführliche Informationen finden Sie unter Zuweisen von Azure-Rollen über das Azure-Portal.

   Einstellung	Wert
   Rolle	Wählen Sie AcrPull aus.
   Zugriff zuweisen zu	Wählen Sie User, group, or service principal (Benutzer, Gruppe oder Dienstprinzipal) aus.
   Mitglieder	Geben Sie den Namen des Projektumgebungstyps ein, der auf das Image im Container zugreifen muss.

   Der Projektumgebungstyp wird wie im folgenden Beispiel angezeigt:

   

In dieser Konfiguration verwendet ADE die verwaltete Identität für PET, unabhängig davon, ob diese systemseitig oder benutzerseitig zugewiesen ist.

Tipp

Diese Rollenzuweisung muss für jeden Projektumgebungstyp vorgenommen werden. Sie kann über die Azure CLI automatisiert werden.

Wenn Sie bereit sind, Ihr Image an Ihre Registrierung zu pushen, führen Sie den folgenden Befehl aus:

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

Öffentliche Registrierung

Verwenden einer öffentlichen Registrierung mit anonymem Pull

Führen Sie die folgenden Befehle in der Azure-Befehlszeilenschnittstelle aus, um Ihre Registrierung so einzurichten, dass das anonyme Pullen von Images aktiviert ist:

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

Wenn Sie bereit sind, Ihr Image an Ihre Registrierung zu pushen, führen Sie den folgenden Befehl aus:

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

Signieren eines Containerimages mit Notation

Anstatt Ihr benutzerdefiniertes Image zu erstellen und selbst in eine Containerregistrierung zu übertragen, können Sie ein Skript zum Erstellen und Pushen in eine angegebene Containerregistrierung verwenden.

Microsoft bietet ein Schnellstartskript, mit dem Sie Ihr benutzerdefiniertes Image erstellen und an eine Registrierung pushen können. Das Skript erstellt Ihr Image und überträgt es unter dem Repository ade und dem Tag latest an eine angegebene Azure Container Registry (ACR).

Um das Skript zu verwenden, müssen Sie Folgendes tun:

1. Erstellen Sie einen Dockerfile- und Skriptordner, um das ADE-Erweiterbarkeitsmodell zu unterstützen.
2. Geben Sie einen Registrierungsnamen und ein Verzeichnis für Ihr benutzerdefiniertes Image an.
3. Azure CLI und Docker Desktop müssen installiert und in Ihren PATH-Variablen enthalten sein.
4. Docker Desktop muss ausgeführt werden.
5. Sie müssen über Berechtigungen zum Pushen an die angegebene Registrierung verfügen.

Sie können das Skript hier anzeigen.

Sie können das Skript mit dem folgenden Befehl in PowerShell aufrufen:

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

Wenn Sie außerdem an ein bestimmtes Repository und einen bestimmten Tagnamen pushen möchten, können Sie Folgendes ausführen:

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

Verbinden des Images mit Ihrer Umgebungsdefinition

Wenn Sie Umgebungsdefinitionen erstellen, die Ihr benutzerdefiniertes Image in Ihrer Bereitstellung verwenden sollen, bearbeiten Sie die runner-Eigenschaft in der Manifestdatei („environment.yaml“ oder „manifest.yaml“).

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

Weitere Informationen zum Erstellen von Umgebungsdefinitionen, die die ADE-Containerimages zum Bereitstellen Ihrer Azure-Ressourcen verwenden, finden Sie unter Hinzufügen und Konfigurieren einer Umgebungsdefinition.

Zugehöriger Inhalt

• ADE CLI-Referenz für benutzerdefinierte Runner-Images
• ADE CLI-Variablenreferenz

• Repository azure-deployment-environments von Pulumi