Configurer une image conteneur pour exécuter des déploiements

Utiliser un exemple d’image conteneur

ADE prend en charge ARM et Bicep sans nécessiter de configuration supplémentaire. Vous pouvez créer une définition d’environnement qui déploie des ressources Azure pour un environnement de déploiement en ajoutant les fichiers de modèle (comme azuredeploy.json et environment.yaml) à votre catalogue. ADE utilise ensuite l’exemple d’image conteneur ARM-Bicep pour créer l’environnement de déploiement.

Dans le fichier environment.yaml, la propriété runner spécifie l’emplacement de l’image conteneur que vous souhaitez utiliser. Pour utiliser l’exemple d’image publié sur le Registre des artefacts Microsoft, utilisez les identificateurs runner respectifs.

L’exemple suivant montre un runner qui référence l’exemple d’image conteneur ARM-Bicep :

    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

Vous pouvez voir l’exemple d’image conteneur Bicep dans l’exemple de référentiel ADE sous le dossier Runner-Images pour l’image ARM-Bicep.

Pour plus d’informations sur la création de définitions d’environnement qui utilisent les images conteneur ADE pour déployer vos ressources Azure, consultez Ajouter et configurer une définition d’environnement.

Utilisez une image personnalisée pour configurer une image Terraform.

Utiliser un exemple d’image conteneur fournie par Pulumi

L’équipe Pulumi fournit une image prédéfinie pour vous aider à démarrer, que vous pouvez voir dans le dossier Runner-Image. Cette image est disponible publiquement sur le Docker Hub de Pulumi en tant que pulumi/azure-deployment-environments. Vous pouvez donc l’utiliser directement à partir de vos définitions d’environnement ADE.

Voici un exemple de fichier environment.yaml qui utilise l’image prédéfinie :

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

Vous trouverez quelques exemples de définitions d’environnement dans le dossier Environnements.

Vous pouvez générer et envoyer (push) l’image manuellement, ou utiliser un script fourni par Microsoft pour automatiser le processus.

Vous pouvez également dupliquer (fork) le référentiel Tirer parti du modèle d'extensibilité d'ADE avec Terraform pour générer et envoyer (push) l’image Terraform à un ACR fourni.

Pour créer une image configurée pour ADE, suivez ces étapes :

1. Créer une image personnalisée basée sur un exemple d’image.
2. Installer les packages souhaités.
3. Configurer des scripts d’interpréteur de commandes d’opération.
4. Créer des scripts d’interpréteur de commandes d’opération pour déployer des modèles ARM ou Bicep.

Pour créer une image configurée pour ADE, suivez ces étapes :

1. Créer une image personnalisée basée sur un exemple d’image.
2. Installer les packages souhaités.
3. Configurer des scripts d’interpréteur de commandes d’opération.
4. Créer des scripts d’interpréteur de commandes d’opération qui utilisent l’interface CLI Terraform.

Pour créer une image configurée pour ADE, suivez ces étapes :

1. Créer une image personnalisée basée sur un exemple d’image.
2. Installer les packages souhaités.
3. Configurer des scripts d’interpréteur de commandes d’opération.
4. Créer des scripts d’interpréteur de commandes d’opération qui utilisent l’interface CLI Pulumi.

Lors de cette étape, vous installez tous les packages dont vous avez besoin dans votre image, y compris Bicep. Vous pouvez installer le package Bicep avec Azure CLI en utilisant l’instruction RUN, comme illustré dans l’exemple suivant :

RUN az bicep install

Lors de cette étape, vous installez tous les packages dont vous avez besoin dans votre image, y compris Terraform. Vous pouvez installer l’interface CLI Terraform dans un emplacement exécutable pour pouvoir l’utiliser dans vos scripts de déploiement et de suppression.

Voici un exemple de ce processus, qui installe la version 1.7.5 de l’interface CLI Terraform :

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

Vous pouvez installer l’interface CLI Pulumi dans un emplacement exécutable pour pouvoir l’utiliser dans vos scripts de déploiement et de suppression.

Voici un exemple de ce processus, en installant la dernière version de l’interface CLI Pulumi :

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

En fonction du langage de programmation que vous envisagez d’utiliser pour les programmes Pulumi, vous devrez peut-être installer un ou plusieurs runtimes correspondants. Le runtime Python est déjà disponible dans l’image de base.

Voici un exemple d’installation de Node.js et de TypeScript :

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

4. Créer des scripts d’interpréteur de commandes d’opération pour déployer des modèles ARM ou Bicep

Pour vous assurer que vous pouvez correctement déployer l’infrastructure ARM ou Bicep via ADE, vous devez :

1. Convertir les paramètres ADE en paramètres acceptables pour ARM
2. Résoudre les modèles liés s’ils sont utilisés dans le déploiement
3. Utiliser l’identité managée privilégiée pour effectuer le déploiement

Durant la phase entrypoint de l’image core, tous les paramètres définis pour l’environnement actuel sont stockés sous la variable $ADE_OPERATION_PARAMETERS. Pour les convertir en paramètres acceptables pour ARM, vous pouvez exécuter la commande suivante avec 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) }' )

Ensuite, pour résoudre tous les modèles liés utilisés dans un modèle ARM basé sur JSON, vous pouvez décompiler le fichier de modèle principal, qui résout tous les fichiers d’infrastructure locaux utilisés dans de nombreux modules Bicep. Ensuite, régénérez ces modules dans un modèle ARM unique en incorporant les modèles liés dans le modèle ARM principal en tant que modèles imbriqués. Cette étape est nécessaire uniquement pendant l’opération de déploiement. Le fichier de modèle principal peut être spécifié avec le $ADE_TEMPLATE_FILE défini durant la phase entrypoint de l’image core. Vous devez réinitialiser cette variable avec le fichier de modèle recompilé. Voir l’exemple suivant :

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

Pour fournir à un déploiement les autorisations nécessaires pour exécuter le déploiement et la suppression des ressources au sein de l’abonnement, utilisez l’identité managée privilégiée associée au type d’environnement de projet ADE. Si votre déploiement nécessite des autorisations spéciales, notamment des rôles particuliers, attribuez ces rôles à l’identité du type d’environnement de projet. Parfois, l’identité managée n’est pas immédiatement disponible quand vous entrez le conteneur. Vous pouvez réessayer jusqu’à ce que la connexion réussisse.

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

Pour commencer le déploiement des modèles ARM ou Bicep, exécutez la commande az deployment group create. Lors de l’exécution de cette commande à l’intérieur du conteneur, choisissez un nom de déploiement qui ne remplace pas les déploiements passés, et utilisez les indicateurs --no-prompt true et --only-show-errors pour vous assurer que le déploiement n’échoue pas en cas d’avertissement ou ne se bloque pas en attendant une entrée utilisateur, comme le montre l’exemple suivant :

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

Pour supprimer un environnement, effectuez un déploiement en mode Complete et fournissez un modèle ARM vide qui supprime toutes les ressources dans le groupe de ressources ADE spécifié, comme le montre l’exemple suivant :

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"

Vous pouvez consulter l’état et les détails de l’approvisionnement en exécutant les commandes ci-dessous. ADE utilise des fonctions spéciales pour lire et fournir plus de contexte en fonction des détails de provisionnement, disponibles dans le dossier Runner-Images. Voici un exemple d’implémentation simple :

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

Enfin, pour afficher les sorties de votre déploiement et les passer à ADE afin de les rendre accessibles via Azure CLI, vous pouvez exécuter les commandes suivantes :

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. Créer des scripts d’interpréteur de commandes d’opération qui utilisent l’interface CLI Terraform

Il y a trois étapes pour déployer l’infrastructure via Terraform :

1. terraform init : initialise l’interface CLI Terraform pour effectuer des actions dans le répertoire de travail
2. terraform plan : développe un plan basé sur les fichiers et variables entrants de l’infrastructure Terraform, ainsi que tous les fichiers d’état existants, et développe les étapes nécessaires pour créer ou mettre à jour l’infrastructure spécifiée dans les fichiers .tf
3. terraform apply : applique le plan pour créer une infrastructure ou mettre à jour l’existante dans Azure

Pendant le point d’entrée de l’image de base, tous les fichiers d’état existants sont extraits dans le conteneur et le répertoire enregistré sous la variable d’environnement $ADE_STORAGE. Par ailleurs, tous les paramètres définis pour l’environnement actuel sont stockés sous la variable $ADE_OPERATION_PARAMETERS. Pour accéder au fichier d’état existant et définir vos variables dans un fichier .tfvars.json, exécutez les commandes suivantes :

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

echo "$ADE_OPERATION_PARAMETERS" > $EnvironmentVars

Par ailleurs, pour utiliser les privilèges ADE et déployer l’infrastructure dans votre abonnement, votre script doit utiliser l’identité MSI (Managed Service Identity) pendant l’approvisionnement de l’infrastructure avec le fournisseur Terraform AzureRM. Si votre déploiement a besoin d’autorisations spéciales pour effectuer votre déploiement, comme des rôles particuliers, attribuez ces autorisations à l’identité du type d’environnement de projet utilisée pour le déploiement de votre environnement. Étant donné qu’ADE définit les variables d’environnement appropriées, comme le client, le locataire et les ID d’abonnement au sein du point d’entrée de l’image de base, exécutez les commandes suivantes pour que le fournisseur utilise l’identité MSI ADE :

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

Si vous avez d’autres variables à référencer dans votre modèle qui ne sont pas spécifiées dans les paramètres de votre environnement, définissez des variables d’environnement avec le préfixe TF_VAR. Une liste des variables d’environnement ADE fournies est mise à disposition pour la référence des variables CLI d’environnement de déploiement Azure. Voici un exemple de ces commandes :

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

À présent, vous pouvez exécuter les étapes listées précédemment pour initialiser l’interface CLI Terraform, générer un plan pour l’infrastructure de provisionnement et appliquer un plan pendant votre script de déploiement :

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

Pendant votre script de suppression, vous pouvez ajouter l’indicateur destroy à votre génération de plan afin de supprimer les ressources existantes, comme illustré dans l’exemple suivant :

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

Enfin, pour que les sorties de votre déploiement soient chargées et accessibles quand vous accédez à votre environnement avec Azure CLI, convertissez l’objet de sortie de Terraform au format spécifié par ADE avec le package JQ. Définissez la valeur de la variable d'environnement $ADE_OUTPUTS, comme indiqué dans l’exemple suivant :

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

Il existe quatre étapes pour déployer l’infrastructure via Pulumi :

1. pulumi login : connectez-vous au stockage d’état, dans le système de fichiers local ou dans Pulumi Cloud
2. pulumi stack select : créez ou sélectionnez la pile à utiliser pour l’environnement particulier
3. pulumi config set : passez les paramètres de déploiement en tant que valeurs de configuration Pulumi
4. pulumi up : exécutez le déploiement pour créer une infrastructure ou mettre à jour l’infrastructure existante dans Azure

Pendant le point d’entrée de l’image de base, tous les fichiers d’état locaux existants sont extraits dans le conteneur et le répertoire enregistré sous la variable d’environnement $ADE_STORAGE. Pour accéder au fichier d’état existant, exécutez les commandes suivantes :

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

Pour vous connecter à Pulumi Cloud à la place, définissez votre jeton d’accès Pulumi en tant que variable d’environnement et exécutez les commandes suivantes :

export PULUMI_ACCESS_TOKEN=YOUR_PULUMI_ACCESS_TOKEN
pulumi login

Tous les paramètres définis pour l’environnement actuel sont stockés sous la variable $ADE_OPERATION_PARAMETERS. En outre, la région Azure et le nom du groupe de ressources sélectionnés sont passés respectivement dans ADE_ENVIRONMENT_LOCATION et ADE_RESOURCE_GROUP_NAME. Pour définir votre configuration de pile Pulumi, exécutez les commandes suivantes :

# 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

Par ailleurs, pour utiliser les privilèges ADE et déployer l’infrastructure dans votre abonnement, votre script doit utiliser l’identité MSI (Managed Service Identity) ADE pendant l’approvisionnement de l’infrastructure à l’aide du fournisseur Pulumi Azure natif ou Azure Classic. Si votre déploiement a besoin d’autorisations spéciales pour effectuer votre déploiement, comme des rôles particuliers, attribuez ces autorisations à l’identité du type d’environnement de projet utilisée pour le déploiement de votre environnement. Étant donné qu’ADE définit les variables d’environnement appropriées, comme le client, le locataire et les ID d’abonnement au sein du point d’entrée de l’image de base, exécutez les commandes suivantes pour que le fournisseur utilise l’identité MSI ADE :

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

À présent, vous pouvez exécuter la commande pulumi up pour exécuter le déploiement :

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

Sinon, pendant votre script de suppression, vous pouvez exécuter la commande destroy, comme illustré dans l’exemple suivant :

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

Enfin, pour que les sorties de votre déploiement soient chargées et accessibles quand vous accédez à votre environnement avec Azure CLI, convertissez l’objet de sortie de Pulumi au format spécifié par ADE avec le package JQ. Définissez la valeur de la variable d'environnement $ADE_OUTPUTS, comme indiqué dans l’exemple suivant :

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