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

Ambienti di distribuzione di Azure supporta un modello di estendibilità che consente di configurare la definizione dell'ambiente con il framework di modelli IaC preferito. È possibile archiviare immagini personalizzate in un registro contenitori come Registro Azure Container (ACR) o Docker Hub e quindi farvi riferimento nelle definizioni di ambiente per distribuire gli ambienti.

Questo articolo illustra come creare immagini di contenitori Bicep personalizzate per distribuire le definizioni di ambiente in ADE. Si apprenderà come usare un'immagine standard fornita da Microsoft o come configurare un'infrastruttura di provisioning di immagini personalizzata usando il framework IaC (Infrastructure-as-Code) bicep.

Questo articolo illustra come creare immagini di contenitori Terraform personalizzate per creare ambienti di distribuzione con Azure Deployment Environments (ADE). Si apprenderà come configurare un'immagine personalizzata per eseguire il provisioning dell'infrastruttura usando il framework Infrastructure-as-Code (IaC) di Terraform.

Questo articolo illustra come usare Pulumi per le distribuzioni in ADE. Si apprenderà come usare un'immagine standard fornita da Pulumi o come configurare un'immagine personalizzata per effettuare il provisioning dell'infrastruttura usando il framework Infrastructure-as-Code (IaC) di Pulumi.

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 standard Per scenari semplici, usare l'immagine del contenitore ARM-Bicep standard fornita da ADE.
• Creare un'immagine del contenitore personalizzata: per scenari più complessi, creare un'immagine del contenitore personalizzata che soddisfi i requisiti specifici.

Usare un'immagine del contenitore standard

ADE supporta Azure Resource Manager (ARM) 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. AdE usa quindi l'immagine del contenitore ARM-Bicep standard 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 standard pubblicata nel Registro artefatti Microsoft, usare i rispettivi identificatori runner.

L'esempio seguente mostra un runner oggetto che fa riferimento all'immagine del contenitore ARM-Bicep standard:

    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 Bicep standard nel repository standard DIE nella cartella Runner-Images per l'immagine ARM-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.

Creare un'immagine personalizzata del contenitore

Creare un'immagine personalizzata usando uno script

Creare un'immagine del contenitore personalizzata usando uno script

La creazione di un'immagine del contenitore personalizzata consente di personalizzare le distribuzioni in base alle esigenze. È possibile creare e compilare un'immagine basata sull'immagine standard DIE ed eseguirne il push nel registro contenitori usando uno script di avvio rapido fornito da Microsoft. È possibile trovare lo script nel repository Ambienti di distribuzione. Per usare lo script di avvio rapido, creare una copia tramite fork del repository e quindi eseguire lo script in locale.

Lo script compila un'immagine e lo inserisce nel Registro Azure Container specificato (ACR) nel repository "ade" e nel tag "latest". Questo script richiede il nome e la directory del Registro di sistema per l'immagine personalizzata, avere installato l'interfaccia della riga di comando di Azure e Docker Desktop e nelle variabili PATH e che disponga delle autorizzazioni necessarie per eseguire il push nel Registro di sistema specificato.

Per usare lo script di avvio rapido per compilare ed eseguire rapidamente il push di questa immagine di esempio in un Registro Azure Container, è necessario:

• Creare una copia tramite fork di questo repository nell'account personale.
• Verificare che l'interfaccia della riga di comando di Azure e l'applicazione Docker Desktop siano installati nel computer e nelle variabili PATH.
• Assicurarsi di disporre delle autorizzazioni necessarie per eseguire il push delle immagini nell'Registro Azure Container selezionato.

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

Per usare l'immagine nelle distribuzioni dell'ambiente, è necessario aggiungere il percorso dell'immagine al file manifesto Connettere l'immagine alla definizione dell'ambiente e potrebbe essere necessario configurare le autorizzazioni per il Registro Azure Container per rendere l'immagine personalizzata disponibile per AdE.

Creare un'immagine personalizzata manualmente

Creare manualmente un'immagine del contenitore 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 standard DIE.

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

Le immagini personalizzate vengono compilate usando le immagini standard DIE come base con l'interfaccia della riga di comando di ADE, preinstallate nelle immagini standard. 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 standard.
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.

1. Creare un'immagine personalizzata basata su un'immagine standard

Creare un DockerFile che includa un'istruzione FROM che punta a un'immagine standard ospitata in Registro artefatti Microsoft.

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

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

Le immagini standard DIE si basano sull'immagine dell'interfaccia della riga di comando di Azure e includono i pacchetti dell'interfaccia della riga di comando di Ade e JQ preinstallati. 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 standard, 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

Compilare l'immagine personalizzata

È 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

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:

• Creare un'immagine del contenitore personalizzata usando uno script: usare lo script pubblicato per creare un'immagine specifica di Terraform.
• Creare un'immagine del contenitore personalizzata sfruttando un flusso di lavoro GitHub: usare il flusso di lavoro GitHub pubblicato dal repository Utilizzo del modello di estendibilità di ADE con Terraform.
• Creare manualmente un'immagine del contenitore personalizzata: creare manualmente un'immagine specifica di Terraform personalizzata

Creare un'immagine personalizzata del contenitore

Creare un'immagine usando uno script

Creare un'immagine del contenitore personalizzata usando uno script

La creazione di un'immagine del contenitore personalizzata consente di personalizzare le distribuzioni in base alle esigenze. È possibile compilare un'immagine basata sull'immagine standard DIE ed eseguirne il push nel registro contenitori usando uno script di avvio rapido fornito da Microsoft. È possibile trovare lo script negli ambienti di distribuzione con il repository Terraform. Per usare lo script di avvio rapido, creare una copia tramite fork del repository e quindi eseguire lo script in locale.

Per usare lo script di avvio rapido per compilare ed eseguire rapidamente il push di questa immagine di esempio in un Registro Azure Container, è necessario:

• Creare una copia tramite fork di questo repository nell'account personale.
• Verificare che l'interfaccia della riga di comando di Azure e l'applicazione Docker Desktop siano installati nel computer e nelle variabili PATH.
• Assicurarsi di disporre delle autorizzazioni necessarie per eseguire il push delle immagini nell'Registro Azure Container selezionato.

Lo script compila un'immagine e lo inserisce nel Registro Azure Container specificato (ACR) nel repository "ade" e nel tag "latest". Questo script richiede il nome e la directory del Registro di sistema per l'immagine personalizzata, avere installato l'interfaccia della riga di comando di Azure e Docker Desktop e nelle variabili PATH e che disponga delle autorizzazioni necessarie per eseguire il push nel Registro di sistema specificato. È 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}'

Per usare l'immagine nelle distribuzioni dell'ambiente, è necessario aggiungere il percorso dell'immagine al file manifesto Connettere l'immagine alla definizione dell'ambiente e potrebbe essere necessario configurare le autorizzazioni per il Registro Azure Container per rendere l'immagine personalizzata disponibile per AdE.

Creare un'immagine usando un flusso di lavoro GitHub

Creare un'immagine del contenitore personalizzata usando un flusso di lavoro GitHub

Per iniziare, è possibile usare il flusso di lavoro GitHub pubblicato dal repository Extensibility Model with Terraform di ADE.

Per usare il flusso di lavoro, è necessario:

• Creare una copia tramite fork di questo repository nell'account personale
• Consentire a GitHub Actions di connettersi ad Azure tramite le credenziali federate di un'applicazione Microsoft Entra ID tramite OIDC. Per altre informazioni su questo processo, vedere qui
• Configurare i segreti del repository per il repository contenente l'ID applicazione dell'applicazione Microsoft Entra ID impostato come AZURE_CLIENT_ID, l'ID sottoscrizione impostato come AZURE_SUBSCRIPTION_ID e l'ID tenant impostato come AZURE_TENANT_ID
• Configurare le variabili del repository per il repository contenente il nome Registro Azure Container personale (ACR) come REGISTRY_NAME, il nome del repository preferito come REPOSITORY_NAME e il tag preferito come TAG per l'immagine creata. È possibile modificare le variabili tra le esecuzioni del flusso di lavoro per eseguire il push dell'immagine generata in registri, repository e tag diversi.

Eseguire il flusso di lavoro passando alla scheda Azioni nel repository con fork e selezionando il flusso di lavoro da eseguire. È quindi possibile selezionare il pulsante Esegui flusso di lavoro per avviare il flusso di lavoro.

Per usare l'immagine nelle distribuzioni dell'ambiente, è necessario aggiungere il percorso dell'immagine al file manifesto Connettere l'immagine alla definizione dell'ambiente e potrebbe essere necessario configurare le autorizzazioni per il Registro Azure Container per rendere l'immagine personalizzata disponibile per AdE.

Creare un'immagine manualmente

Creare manualmente un'immagine del contenitore 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 standard DIE.

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.

GitHub Action pubblicato consente di compilare ed eseguire il push di un'immagine in un Registro Azure Container (ACR). È possibile fare riferimento a un collegamento all'immagine del Registro Azure Container fornito all'interno di una definizione di ambiente in ADE per distribuire o eliminare un ambiente con l'immagine fornita.

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

1. Creare un'immagine personalizzata basata su un flusso di lavoro GitHub.
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.

1. Creare un'immagine personalizzata basata su un flusso di lavoro GitHub

Usare il repository pubblicato per sfruttare il flusso di lavoro di GitHub. Il repository contiene componenti di immagine di esempio compatibili con ADE, inclusi un Dockerfile e script della shell per la distribuzione e l'eliminazione di ambienti usando i modelli IaC terraform. Questo codice di esempio consente di creare un'immagine del contenitore personalizzata.

2. Installare i pacchetti necessari In questo passaggio, installare 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.

3. Configurare gli script della shell delle operazioni

All'interno delle immagini standard, 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 scripts per Terraform.

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 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:

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

echo "$ADE_OPERATION_PARAMETERS" > $EnvironmentVars

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

Compilare l'immagine personalizzata

È 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

Usare un'immagine contenitore standard 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

La creazione di un'immagine del contenitore personalizzata consente di personalizzare le distribuzioni in base alle esigenze. È possibile creare immagini personalizzate basate sulle immagini standard pulumi e personalizzarle in base alle esigenze. Dopo aver completato la personalizzazione dell'immagine, è necessario compilare l'immagine ed eseguirne il push nel registro contenitori.

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

1. Creare un'immagine personalizzata basata su un'immagine standard.
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 standard

Creare un DockerFile che includa un'istruzione FROM che punta a un'immagine standard ospitata in Registro artefatti Microsoft.

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

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

È 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 standard DIE si basano sull'immagine dell'interfaccia della riga di comando di Azure e includono i pacchetti dell'interfaccia della riga di comando di Ade e JQ preinstallati. 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.

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 l'immagine personalizzata

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

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