Configurare l’immagine del contenitore per l’esecuzione di distribuzioni

Questo articolo illustra come creare immagini del contenitore personalizzate per distribuire le definizioni di ambiente in Crittografia dischi di Azure (ADE).

Questo articolo illustra come creare immagini di contenitori Terraform personalizzate per distribuire le definizioni di ambiente in Ambienti di distribuzione di Azure. Si apprenderà come configurare un'immagine personalizzata per eseguire il provisioning dell'infrastruttura usando il framework Infrastructure-as-Code (IaC) di Terraform.

In questo articolo si apprenderà come usare Pulumi per le distribuzioni in Ambienti di distribuzione di Azure (ADE). Si apprenderà come usare un'immagine di esempio fornita da Pulumi o come configurare un'immagine personalizzata per effettuare il provisioning dell'infrastruttura usando il framework Infrastructure-as-Code (IaC) di Pulumi.

ADE supporta un modello di estendibilità che consente di creare immagini personalizzate utilizzabili nelle definizioni dell'ambiente. Per usare questo modello di estendibilità, creare immagini personalizzate e archiviarle in un registro contenitori come Registro Azure Container (ACR) o Docker Hub. Quindi sarà possibile fare riferimento a queste immagini nelle definizioni dell'ambiente per distribuire gli ambienti.

Una definizione di ambiente include almeno due file: un file modello, ad esempio azuredeploy.json o main.bicep, e un file manifesto denominato environment.yaml. ADE usa i contenitori per distribuire le definizioni di ambiente.

Il team di Crittografia dischi di Azure offre una selezione di immagini per iniziare, tra cui un'immagine di base e un'immagine di Azure Resource Manager (ARM)-Bicep. È possibile accedere a queste immagini di esempio nella cartella Runner-Images.

Una definizione di ambiente include almeno due file: un file modello, ad esempio main.tf, e un file manifesto denominato environment.yaml. Si usa un contenitore per distribuire la definizione di ambiente che usa Terraform.

Una definizione di ambiente include almeno due file: un file di progetto Pulumi, Pulumi.yaml, e un file manifesto denominato environment.yaml. Inoltre potrebbe contenere un programma utente scritto nel linguaggio di programmazione preferito: C#, TypeScript, Python e così via. ADE usa i contenitori per distribuire le definizioni di ambiente.

Prerequisiti

• Un account Azure con una sottoscrizione attiva. Creare un account gratuitamente.
• Ambienti di distribuzione di Azure configurati nella sottoscrizione di Azure.
  • Per configurare Ambienti di distribuzione di Azure, seguire la procedura in Avvio rapido: Configurare Ambienti di distribuzione di Azure.

Usare immagini del contenitore con Ambienti di distribuzione di Azure

È possibile adottare uno degli approcci seguenti per usare le immagini del contenitore con Ambienti di distribuzione di Azure:

• Usare un’immagine del contenitore di esempio: per scenari semplici, usare l'immagine del contenitore Azure Resource Manager-Bicep di esempio fornita da Crittografia dischi di Azure.
• Creare un'immagine del contenitore personalizzata: per scenari più complessi, creare un'immagine del contenitore personalizzata che soddisfi i requisiti specifici.

I passaggi principali da seguire quando si usa un'immagine del contenitore sono:

1. Scegliere il tipo di immagine da usare: un'immagine di esempio o un'immagine personalizzata.
   • Se si usa un'immagine personalizzata, iniziare con un'immagine di esempio e quindi personalizzarla in base alle esigenze.
2. Compilare l'immagine.
3. Caricare l'immagine in un registro privato o in un registro pubblico.
4. Configurare l’accesso al registro.
   • Configurare un pull anonimo per un registro pubblico.
   • Assegnare le autorizzazioni di Registro Azure Container di DevCenter per un registro privato.
5. Aggiungere il percorso dell'immagine al parametro runner nella definizione di ambiente
6. Distribuire ambienti che usano l'immagine personalizzata.

Il primo passaggio della procedura consiste nello scegliere il tipo di immagine da usare. Selezionare la scheda corrispondente per visualizzare la procedura.

Usare un'immagine del contenitore di esempio

Usare un'immagine del contenitore di esempio

Crittografia dischi di Azure supporta Azure Resource Manager e Bicep senza richiedere alcuna configurazione aggiuntiva. È possibile creare una definizione di ambiente che distribuisca le risorse di Azure per un ambiente di distribuzione aggiungendo i file modello (ad esempio azuredeploy.json ed environment.yaml) al catalogo. Crittografia dischi di Azure usa quindi l'immagine del contenitore di Azure Resource Manager - Bicep di esempio per creare l'ambiente di distribuzione.

Nel file environment.yaml la proprietà runner specifica il percorso dell'immagine del contenitore da usare. Per usare l'immagine di esempio pubblicata nel Registro artefatti Microsoft, usare gli identificatori corrispondentirunner.

L'esempio seguente mostra uno runner che fa riferimento all'immagine del contenitore di Azure Resource Manager-Bicep di esempio:

    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

È possibile visualizzare l'immagine del contenitore di Bicep di esempio nel repository di esempio di Crittografia dischi di Azure nella cartella Runner-Images per l'immagine di Azure Resource Manager-Bicep.

Per altre informazioni su come creare definizioni di ambiente che usano le immagini del contenitore di Ambienti di distribuzione di Azure per distribuire le risorse di Azure, vedere Aggiungere e configurare una definizione di ambiente.

Usare un'immagine personalizzata per configurare un'immagine Terraform.

Usare un’immagine del contenitore di esempio fornita da Pulumi

Il team Pulumi fornisce un'immagine predefinita per le attività iniziali, visualizzabile nella cartella Strumento di esecuzione-immagine. Questa immagine è disponibile pubblicamente nel Docker Hub di Pulumi come pulumi/azure-deployment-environments, così da poterla usare direttamente dalle definizioni dell'ambiente ADE.

Un file environment.yaml di esempio che usa l’immagine predefinita è il seguente:

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

Nella cartella Ambienti è possibile trovare alcune definizioni di ambiente di esempio.

Creare un'immagine personalizzata

Creare un'immagine personalizzata

La creazione di un'immagine del contenitore personalizzata consente di personalizzare le distribuzioni in base alle esigenze. È possibile creare immagini personalizzate basate sulle immagini del contenitore di esempio di Crittografia dischi di Azure.

Dopo aver completato la personalizzazione dell'immagine, è necessario compilare l'immagine ed eseguirne il push nel registro contenitori.

È possibile creare ed eseguire il push dell'immagine manualmente oppure usare uno script fornito da Microsoft per automatizzare il processo.

In alternativa, è possibile creare una copia tramite fork del repository Sfruttare il modello di estendibilità di ADE con Terraform per creare ed eseguire il push dell'immagine Terraform in un determinato Registro Azure Container.

Le immagini personalizzate vengono create usando le immagini di esempio di Crittografia dischi di Azure come base con l'interfaccia della riga di comando di Crittografia dischi di Azure, preinstallate nelle immagini di esempio. Per altri dettagli sull'interfaccia della riga di comando di ADE, vedere il Riferimento immagine strumento di esecuzione personalizzato interfaccia della riga di comando.

Questo esempio illustra come creare un'immagine Docker per usare le distribuzioni di Ambienti di distribuzione di Azure e accedere all'interfaccia della riga di comando di Ambienti di distribuzione di Azure, basando l'immagine su una delle immagini create da Ambienti di distribuzione di Azure.

Per creare un'immagine configurata per Ambienti di distribuzione di Azure, seguire questa procedura:

1. Creare un'immagine personalizzata basata su un’immagine di esempio.
2. Installare i pacchetti desiderati.
3. Configurare gli script della shell delle operazioni.
4. Creare script della shell delle operazioni per distribuire modelli di Azure Resource Manager o Bicep.

Per creare un'immagine configurata per Ambienti di distribuzione di Azure, seguire questa procedura:

1. Creare un'immagine personalizzata basata su un’immagine di esempio.
2. Installare i pacchetti desiderati.
3. Configurare gli script della shell delle operazioni.
4. Creare script della shell delle operazioni che usano l'interfaccia della riga di comando di Terraform.

Per creare un'immagine configurata per Ambienti di distribuzione di Azure, seguire questa procedura:

1. Creare un'immagine personalizzata basata su un’immagine di esempio.
2. Installare i pacchetti desiderati.
3. Configurare gli script della shell delle operazioni.
4. Creare script della shell delle operazioni che usano l'interfaccia della riga di comando di Pulumi.

1. Creare un'immagine personalizzata basata su un’immagine di esempio

Creare un DockerFile che includa un'istruzione FROM e che punta a un'immagine di esempio ospitata nel Registro artefatti Microsoft.

Ecco un'istruzione FROM di esempio che fa riferimento all'immagine principale campione:

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

Questa istruzione esegue il pull dell’immagine principale più recente pubblicata, rendendola come base per l'immagine personalizzata.

2. Installare i pacchetti necessari

In questo passaggio si installano tutti i pacchetti necessari nell'immagine, incluso Bicep. È possibile installare il pacchetto Bicep con l'interfaccia della riga di comando di Azure usando l'istruzione RUN, come illustrato nell'esempio seguente:

RUN az bicep install

In questo passaggio si installano tutti i pacchetti necessari nell'immagine, incluso Terraform. È possibile installare l'interfaccia della riga di comando di Terraform in un percorso eseguibile, così che possa essere usata negli script di distribuzione ed eliminazione.

Ecco un esempio di questo processo, con installazione della versione 1.7.5 dell'interfaccia della riga di comando di 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

Suggerimento

È possibile ottenere l'URL di download per la versione preferita dell'interfaccia della riga di comando di Terraform dalla pagina delle versioni di Hashicorp.

È possibile installare l'interfaccia della riga di comando di Pulumi in un percorso eseguibile, così che possa essere usata negli script di distribuzione ed eliminazione.

Ecco un esempio di questo processo: installazione della versione più recente dell'interfaccia della riga di comando di Pulumi:

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

A seconda del linguaggio di programmazione che si desidera usare per i programmi Pulumi, potrebbe essere necessario installare uno o più runtime corrispondenti. Il runtime di Python è già disponibile nell'immagine di base.

Ecco un esempio dell’installazione di Node.js e TypeScript:

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

Le immagini campione di ADE si basano sull'immagine dell'interfaccia della riga di comando di Azure e includono i pacchetti preinstallati dell'interfaccia della riga di comando di ADE e JQ. Altre informazioni su'interfaccia della riga di comando di Azure e sul pacchetto JQ.

Per installare eventuali altri pacchetti necessari all'interno dell'immagine, usare l'istruzione RUN.

3. Configurare gli script della shell delle operazioni

All'interno delle immagini campione, le operazioni vengono determinate ed eseguite in base al nome dell'operazione. Attualmente, i due nomi operazione supportati sono distribuire ed eliminare.

Per configurare l'immagine personalizzata e usare tale struttura, specificare una cartella a livello degli script denominati Dockerfile, e quindi specificare due file: deploy.sh e delete.sh. Lo script della shell di distribuzione viene eseguito quando l'ambiente viene creato o ridistribuito, e lo script della shell di eliminazione viene eseguito quando l'ambiente viene eliminato. È possibile visualizzare esempi di script della shell nel repository nella cartella Runner-Images per l'immagine ARM-Bicep.

Per accertare che gli script della shell siano eseguibili, aggiungere al Dockerfile le righe seguenti:

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

4. Creare script della shell delle operazioni per distribuire i modelli di Azure Resource Manager o Bicep

Per assicurarsi di poter distribuire correttamente l'infrastruttura ARM o Bicep tramite Ambienti di distribuzione di Azure, è necessario:

1. Convertire i parametri di Ambienti di distribuzione di Azure in parametri accettabili per ARM
2. Risolvere i modelli collegati se vengono usati nella distribuzione
3. Usare l'identità gestita con privilegi per eseguire la distribuzione

Nel punto di ingresso dell'immagine di base, i parametri impostati per l'ambiente corrente vengono archiviati nella variabile $ADE_OPERATION_PARAMETERS. Per convertirli in parametri accettabili per ARM, è possibile eseguire il comando seguente usando 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) }' )

Successivamente, per risolvere tutti i modelli collegati usati all'interno di un modello di ARM basato su JSON, è possibile decompilare il file modello principale, operazione che risolve tutti i file di infrastruttura locale usati in molti moduli Bicep. Ricompilare quindi questi moduli in un singolo modello di ARM con i modelli collegati incorporati nel modello di ARM di base come modelli annidati. Questo passaggio è necessario solo durante l'operazione di distribuzione. È possibile specificare il file modello di base usando $ADE_TEMPLATE_FILE impostato durante il punto di ingresso dell'immagine di base ed è necessario reimpostare questa variabile con il file modello ricompilato. Vedere l'esempio seguente:

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

Per fornire le autorizzazioni necessarie per la distribuzione e l'eliminazione delle risorse all'interno della sottoscrizione, usare l'identità gestita con privilegi associata al tipo di ambiente del progetto Ambienti di distribuzione di Azure. Se per completare la distribuzione sono necessarie autorizzazioni speciali, ad esempio ruoli specifici, assegnare tali ruoli all'identità del tipo di ambiente del progetto. In alcuni casi, l'identità gestita non è immediatamente disponibile quando si immette il contenitore; è possibile riprovare fino a quando l'accesso non riesce.

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

Per iniziare la distribuzione dei modelli ARM o Bicep, eseguire il comando az deployment group create. Quando si esegue questo comando all'interno del contenitore, scegliere un nome di distribuzione che non comporti la sostituzione delle distribuzioni precedenti e usare i flag --no-prompt true e --only-show-errors per assicurarsi che la distribuzione non fallisca in caso di avvisi e che non si blocchi in attesa dell'input dell'utente, come illustrato nell'esempio seguente:

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

Per eliminare un ambiente, eseguire una distribuzione in modalità completa e fornire un modello di ARM vuoto, che rimuove tutte le risorse all'interno del gruppo di risorse di Ambienti di distribuzione di Azure specificato, come illustrato nell'esempio seguente:

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"

È possibile controllare lo stato e i dettagli del provisioning eseguendo i comandi seguenti. Ambienti di distribuzione di Azure usa alcune funzioni speciali per leggere e fornire più contesto in base ai dettagli del provisioning, disponibili nella cartella Runner-Images. Un'implementazione semplice può essere la seguente:

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

Infine, per visualizzare gli output della distribuzione e passarli ad Ambienti di distribuzione di Azure per renderli accessibili tramite l'interfaccia della riga di comando di Azure, è possibile eseguire i comandi seguenti:

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. Creare script della shell delle operazioni che usano l'interfaccia della riga di comando di Terraform

La distribuzione dell'infrastruttura tramite Terraform avviene in quattro passaggi:

1. terraform init: inizializza l'interfaccia della riga di comando di Terraform per eseguire azioni all'interno della directory di lavoro
2. terraform plan: sviluppa un piano basato sui file e sulle variabili dell'infrastruttura Terraform in ingresso ed eventuali file di stato esistenti e sviluppa i passaggi necessari per creare o aggiornare l'infrastruttura specificata nei file .tf
3. terraform apply: applica il piano per creare un'infrastruttura nuova o aggiornare l'infrastruttura esistente in Azure

Nel punto di ingresso dell'immagine di base viene eseguito il pull di tutti i file di stato locali esistenti nel contenitore e nella directory salvati nella variabile di ambiente $ADE_STORAGE. Inoltre, i parametri impostati per l'ambiente corrente vengono archiviati nella variabile $ADE_OPERATION_PARAMETERS. Per accedere al file di stato esistente e impostare le variabili all'interno di un file .tfvars.json, eseguire i comandi seguenti:

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

echo "$ADE_OPERATION_PARAMETERS" > $EnvironmentVars

Inoltre, per usare i privilegi di Ambienti di distribuzione di Azure per distribuire l'infrastruttura all'interno della sottoscrizione, lo script deve usare l'identità del servizio gestita (MSI) di Ambienti di distribuzione di Azure se effettua il provisioning dell'infrastruttura usando il provider AzureRM Terraform. Se per il suo completamento la distribuzione richiede autorizzazioni speciali, ad esempio ruoli specifici, assegnare tali autorizzazioni all'identità del tipo di ambiente del progetto usata per la distribuzione dell'ambiente. Ambienti di distribuzione di Azure imposta le variabili di ambiente pertinenti, ad esempio gli ID client, tenant e sottoscrizione all'interno del punto di ingresso dell'immagine di base, quindi è necessario eseguire i comandi seguenti per assicurarsi che il provider usi l'identità del servizio gestita di Ambienti di distribuzione di Azure:

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

Se sono presenti altre variabili a cui fare riferimento all'interno del modello che non sono specificate nei parametri dell'ambiente, impostare le variabili di ambiente usando il prefisso TF_VAR. Un elenco delle variabili di ambiente di Ambienti di distribuzione di Azure è disponibile nel Riferimento alle variabili dell'interfaccia della riga di comando di Ambienti di distribuzione di Azure. Un esempio di questi comandi potrebbe essere;

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

È ora possibile eseguire i passaggi elencati in precedenza per inizializzare l'interfaccia della riga di comando di Terraform, generare un piano per l'infrastruttura di provisioning e applicare un piano durante lo script di distribuzione:

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

Durante lo script di eliminazione, è possibile aggiungere il flag destroy alla generazione del piano per eliminare le risorse esistenti, come illustrato nell'esempio seguente:

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

Infine, per far sì che gli output della distribuzione siano caricati e disponibili quando si accede all'ambiente tramite l'interfaccia della riga di comando di Azure, tramite il pacchetto JQ trasformare l'oggetto di output da Terraform al formato specificato da Ambienti di distribuzione di Azure. Impostare il valore sulla variabile di ambiente $ADE_OUTPUTS, come mostrato nell'esempio seguente:

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

La distribuzione dell'infrastruttura tramite Pulumi avviene in quattro passaggi:

1. pulumi login - connettersi alla risorsa di archiviazione dello stato, nel file system locale o in Pulumi Cloud
2. pulumi stack select - creare o selezionare lo stack da usare per il dato ambiente specifico
3. pulumi config set - passare i parametri di distribuzione come valori di configurazione Pulumi
4. pulumi up - eseguire la distribuzione per creare un'infrastruttura nuova o aggiornare quella esistente in Azure

Nel corso dell’entrypoint di immagine principale, viene eseguito il pull di tutti i file di stato locali esistenti nel contenitore, e la directory salvata nella variabile di ambiente $ADE_STORAGE. Per accedere al file di stato esistente, eseguire i comandi seguenti:

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

Invece, per accedere a Pulumi Cloud, impostare il token di accesso Pulumi come variabile di ambiente, quindi eseguire i comandi seguenti:

export PULUMI_ACCESS_TOKEN=YOUR_PULUMI_ACCESS_TOKEN
pulumi login

I parametri impostati per l'ambiente corrente vengono archiviati nella variabile $ADE_OPERATION_PARAMETERS. Inoltre, l’area di Azure e il nome del gruppo di risorse selezionati vengono passati rispettivamente in ADE_ENVIRONMENT_LOCATION e ADE_RESOURCE_GROUP_NAME. Per impostare la configurazione dello stack Pulumi, eseguire i comandi seguenti:

# 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

Inoltre, per usare i privilegi di Crittografia dischi di Azure (ADE) per distribuire l'infrastruttura all'interno della sottoscrizione, lo script deve usare l'identità del servizio gestito (MSI) di ADE se effettua il provisioning dell'infrastruttura usando il provider Pulumi Azure Native o Azure in versione classica. Se per il suo completamento la distribuzione richiede autorizzazioni speciali, ad esempio ruoli specifici, assegnare tali autorizzazioni all'identità del tipo di ambiente del progetto usata per la distribuzione dell'ambiente. Crittografia dischi di Azure (ADE) imposta le variabili di ambiente pertinenti, ad esempio gli ID client, tenant e sottoscrizione all'interno dell’entrypoint di immagine base, quindi è necessario eseguire i comandi seguenti per assicurarsi che il provider usi MSI di 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

Ora è possibile eseguire il comando pulumi up per eseguire la distribuzione:

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

Durante lo script di eliminazione, è invece possibile eseguire il comando destroy, come illustrato nell'esempio seguente:

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

Infine, per far sì che gli output della distribuzione siano caricati e disponibili quando si accede all'ambiente tramite l'interfaccia della riga di comando di Azure, tramite il pacchetto JQ trasformare l'oggetto di output da Pulumi al formato specificato da ADE. Impostare il valore sulla variabile di ambiente $ADE_OUTPUTS, come mostrato nell'esempio seguente:

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

Compilare un'immagine

È possibile creare l’immagine tramite l'interfaccia della riga di comando di Docker. Verificare che il motore Docker sia installato nel computer. Passare quindi alla directory del Dockerfile ed eseguire il comando seguente:

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

Ad esempio, se si vuole salvare l'immagine in un repository all'interno del registro denominato customImage e si desidera eseguire il caricamento con la versione tag di 1.0.0, si eseguirà:

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

Rendere l'immagine personalizzata accessibile a Crittografia dischi di Azure

Per usare immagini personalizzate, è necessario archiviarle in un registro contenitori. È possibile usare un registro contenitori pubblico o un registro contenitori privato. È altamente consigliabile usare Registro Azure Container in quanto, grazie alla stretta integrazione con Crittografia dischi di Azure, l'immagine può essere pubblicata senza consentire l'accesso pull anonimo pubblico. È necessario creare l'immagine del contenitore personalizzata ed eseguirne il push in un registro contenitori per renderla disponibile per l'uso in Crittografia dischi di Azure.

È anche possibile archiviare l'immagine in un registro contenitori diverso, ad esempio Docker Hub, ma in tal caso deve essere accessibile pubblicamente.

Attenzione

L'archiviazione dell'immagine del contenitore in un registro con accesso pull anonimo (non autenticato) lo rende accessibile pubblicamente. Non farlo se l'immagine contiene informazioni riservate. Archiviarla invece nel Registro Azure Container con accesso pull anonimo disabilitato.

Per usare un'immagine personalizzata archiviata nel Registro Azure Container, è necessario assicurarsi che Ambienti di distribuzione di Azure disponga delle autorizzazioni appropriate per accedere all'immagine. Quando si crea un'istanza del Registro Azure Container, è sicura per impostazione predefinita e consente solo agli utenti autenticati di ottenere l'accesso.

Pulumi consente di creare un Registro Azure Container e pubblicarvi l'immagine. Fare riferimento all'esempio provisioning/immagine personalizzata per un progetto Pulumi autonomo che crea le risorse necessarie nell'account Azure.

Selezionare la scheda appropriata per altre informazioni su ogni approccio.

Registro privato

Usare un registro privato con accesso protetto

Per impostazione predefinita, l'accesso al pull o al push di contenuto da un Registro Azure Container è disponibile solo per gli utenti autenticati. È possibile proteggere ulteriormente l'accesso al Registro Azure Container limitando l'accesso da determinate reti e assegnando ruoli specifici.

Per creare un'istanza del Registro Azure Container, operazione che si può effettuare tramite interfaccia della riga di comando di Azure, il portale di Azure, comandi di PowerShell e altro ancora, seguire un avvio rapido.

Limitare l'accesso alla rete

Per proteggere l'accesso alla rete per il Registro Azure Container, è possibile limitare l'accesso alle proprie reti o disabilitare completamente l'accesso alla rete pubblica. Se si limita l'accesso alla rete, è necessario abilitare l'eccezione del firewall Consenti ai servizi Microsoft attendibili di accedere a questo registro contenitori.

Per disabilitare l'accesso dalle reti pubbliche:

1. Creare un'istanza del Registro Azure Container o usarne una esistente.

2. Nel portale di Azure passare al Registro Azure Container da configurare.

3. Nel menu a sinistra, in Impostazioni selezionare Rete.

4. Nella pagina Rete, nella scheda Accesso pubblico, in Accesso alla rete pubblica selezionare Disabilitato.

   

5. In Eccezione firewall verificare che Consenti ai servizi Microsoft attendibili di accedere a questo registro contenitori sia selezionato e quindi selezionare Salva.

   

Assegnare il ruolo AcrPull

La creazione di ambienti tramite immagini del contenitore usa l'infrastruttura di Ambienti di distribuzione di Azure, inclusi i progetti e i tipi di ambiente. Ogni progetto ha uno o più tipi di ambiente, che richiedono l'accesso in lettura all'immagine del contenitore che definisce l'ambiente da distribuire. Per accedere alle immagini all'interno del Registro Azure Container in modo sicuro, assegnare il ruolo AcrPull a ogni tipo di ambiente di progetto.

Per assegnare il ruolo AcrPull al tipo di ambiente del progetto:

1. Nel portale di Azure passare al Registro Azure Container da configurare.

2. Nel menu a sinistra selezionare Controllo di accesso (IAM).

3. Seleziona Aggiungi>Aggiungi assegnazione ruolo.

4. Assegnare il ruolo seguente. Per la procedura dettagliata, vedere Assegnare ruoli di Azure usando il portale di Azure.

   Impostazione	Valore
   Ruolo	Selezionare AcrPull.
   Assegna accesso a	Selezionare Utente, gruppo o entità servizio.
   Membri	Immettere il nome del tipo di ambiente del progetto che deve accedere all'immagine nel contenitore.

   Il tipo di ambiente del progetto viene visualizzato come nell'esempio seguente:

   

In questa configurazione, Ambienti di distribuzione di Azure usa l'identità gestita per il tipo di ambiente del progetto, che sia assegnata dal sistema o dall'utente.

Suggerimento

Questa assegnazione di ruolo deve essere eseguita per ogni tipo di ambiente di progetto. L'operazione può essere automatizzata tramite l'interfaccia della riga di comando di Azure.

Quando si è pronti per eseguire il push dell'immagine nel registro, eseguire il comando seguente:

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

Registro pubblico

Usare un registro pubblico con pull anonimo

Per configurare il registro per abilitare il pull di immagini anonime, eseguire i comandi seguenti nell'interfaccia della riga di comando di Azure:

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

Quando si è pronti per eseguire il push dell'immagine nel registro, eseguire il comando seguente:

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

Compilare un'immagine del contenitore con uno script

Anziché creare l'immagine personalizzata ed eseguirne il push in un registro contenitori manualmente, è possibile usare uno script per crearla ed eseguirne il push in un registro contenitori specificato.

Microsoft fornisce uno script di avvio rapido che consente di creare l'immagine personalizzata ed eseguirne il push in un registro. Lo script compila l'immagine ed esegue il push dell'immagine in un Registro Azure Container nel repository ade e con il tag latest.

Per usare lo script, è necessario:

1. Creare un Dockerfile e una cartella per gli script per supportare il modello di estendibilità di Ambienti di distribuzione di Azure.
2. Specificare una directory e un nome del registro per l'immagine personalizzata.
3. Installare l'interfaccia della riga di comando di Azure e Docker Desktop nelle variabili PATH.
4. Assicurarsi che Docker Desktop sia in esecuzione.
5. Disporre delle autorizzazioni per eseguire il push nel registro specificato.

È possibile visualizzare lo script qui.

È possibile chiamare lo script usando il comando seguente in PowerShell:

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

Inoltre, se si vuole eseguire il push in un repository e un nome di tag specifici, è possibile eseguire:

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

Connettere l'immagine alla definizione dell'ambiente

Quando si creano definizioni di ambiente per usare l'immagine personalizzata nella distribuzione, modificare la proprietà runner nel file manifesto (environment.yaml o manifest.yaml).

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

Per altre informazioni su come creare definizioni di ambiente che usano le immagini del contenitore di Ambienti di distribuzione di Azure per distribuire le risorse di Azure, vedere Aggiungere e configurare una definizione di ambiente.

Contenuto correlato

• Riferimento Immagine strumento di esecuzione personalizzato interfaccia della riga di comando di ADE
• Riferimento alle variabili dell'interfaccia della riga di comando di Ambienti di distribuzione di Azure

• Repository azure-deployment-environments di Pulumi