Configurare l'immagine del contenitore per eseguire distribuzioni con ARM e Bicep
Questo articolo illustra come creare immagini personalizzate di Azure Resource Manager (ARM) e contenitori Bicep per distribuire le definizioni di ambiente negli ambienti di distribuzione di Azure(ADE).
Una definizione di ambiente comprende almeno due file: un file modello, ad esempio azuredeploy.json o main.bicep, e un file manifesto denominato environment.yaml. Ade usa contenitori per distribuire definizioni di ambiente e supporta in modo nativo i framework ARM e Bicep IaC.
Il modello di estendibilità DIE consente di creare immagini di contenitori personalizzate da usare con le definizioni dell'ambiente. Usando il modello di estendibilità, è possibile creare immagini di contenitori personalizzate e archiviarle in un registro contenitori come DockerHub. Quindi sarà possibile fare riferimento a queste immagini nelle definizioni dell'ambiente per distribuire gli ambienti.
Il team DIE offre una selezione di immagini per iniziare, tra cui un'immagine principale e un'immagine di Azure Resource Manager (ARM)/Bicep. È possibile accedere a queste immagini di esempio nella cartella Runner-Images .
Prerequisiti
- Un account Azure con una sottoscrizione attiva. Creare un account gratuitamente.
- Ambienti di distribuzione di Azure configurati nella sottoscrizione di Azure.
- Per configurare AdE, seguire la guida introduttiva: Configurare gli ambienti di distribuzione di Azure.
Usare immagini del contenitore con ADE
È possibile adottare uno degli approcci seguenti per usare le immagini del contenitore con ADE:
- Usare l'immagine del contenitore standard: per scenari semplici, usare l'immagine del contenitore 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.
Indipendentemente dall'approccio scelto, è necessario specificare l'immagine del contenitore nella definizione dell'ambiente per distribuire le risorse di Azure.
Usare l'immagine del contenitore Bicep standard
AdE supporta Bicep in modo nativo, quindi è possibile configurare una definizione di ambiente che distribuisce le risorse di Azure per un ambiente di distribuzione aggiungendo i file modello (azuredeploy.json e environment.yaml) al catalogo. AdE usa quindi l'immagine del contenitore Bicep standard per creare l'ambiente di distribuzione.
Nel file environment.yaml la proprietà runner specifica il percorso dell'immagine del contenitore che si vuole usare. Per usare l'immagine di esempio pubblicata nella Registro artefatti Microsoft, usare il rispettivo strumento di esecuzione degli identificatori, come indicato nella tabella seguente.
L'esempio seguente mostra uno strumento di esecuzione che fa riferimento all'immagine del contenitore 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 Bicep standard nel repository di esempio di Ade nella cartella Runner-Images per l'immagine ARM-Bicep .
Per altre informazioni su come creare definizioni di ambiente che usano le immagini del contenitore ADE per distribuire le risorse di Azure, vedere Aggiungere e configurare una definizione di ambiente.
Creare un'immagine del contenitore Bicep 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 standard DIE.
Dopo aver completato la personalizzazione dell'immagine, è necessario compilare l'immagine ed eseguirne il push nel registro contenitori.
Creare e personalizzare un'immagine del contenitore con Docker
In questo esempio si apprenderà come creare un'immagine Docker per usare le distribuzioni di Active Directory e accedere all'interfaccia della riga di comando di Ade, basando l'immagine su una delle immagini create da AdE.
L'interfaccia della riga di comando di ADE è uno strumento che consente di creare immagini personalizzate usando immagini di base DIE. È possibile usare l'interfaccia della riga di comando di Ade per personalizzare le distribuzioni e le eliminazioni in base al flusso di lavoro. L'interfaccia della riga di comando di ADE è preinstallata nelle immagini campione. Per altri dettagli sull'interfaccia della riga di comando di ADE, vedere il Riferimento immagine strumento di esecuzione personalizzato interfaccia della riga di comando.
Per creare un'immagine configurata per Active Directory, seguire questa procedura:
- Basare l'immagine su un'immagine di esempio creata da ADE o sull'immagine preferita usando l'istruzione FROM.
- Installare tutti i pacchetti necessari per l'immagine usando l'istruzione RUN.
- Creare una cartella degli script allo stesso livello del Dockerfile, archiviare i file deploy.sh e delete.sh al suo interno e assicurarsi che tali script siano individuabili ed eseguibili all'interno del contenitore creato. Questo passaggio è necessario per il funzionamento della distribuzione usando l'immagine principale di ADE.
Selezionare un'immagine del contenitore campione usando l'istruzione FROM
Includere un'istruzione FROM all'interno di un DockerFile creato per la nuova immagine, puntando a un'immagine campione 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.
Installare Bicep in un Dockerfile
È 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 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.
Eseguire 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 {} \;
Creare script della shell delle operazioni per distribuire modelli ARM o Bicep
Per assicurarsi di poter distribuire correttamente l'infrastruttura ARM o Bicep tramite AdE, è necessario:
- Convertire i parametri DIE in parametri arm-accettabili
- Risolvere i modelli collegati se vengono usati nella distribuzione
- Usare l'identità gestita con privilegi per eseguire la distribuzione
Durante il punto di ingresso dell'immagine principale, tutti i parametri impostati per l'ambiente corrente vengono archiviati nella variabile $ADE_OPERATION_PARAMETERS. Per convertirli in parametri arm-accettabili, è 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 basato su ARM JSON, è possibile decompilare il file modello principale, che risolve tutti i file di infrastruttura locale usati in molti moduli Bicep. Ricompilare quindi questi moduli in un singolo modello di Resource Manager con i modelli collegati incorporati nel modello di Resource Manager principale come modelli annidati. Questo passaggio è necessario solo durante l'operazione di distribuzione. Il file modello principale può essere specificato usando il set durante il $ADE_TEMPLATE_FILE punto di ingresso dell'immagine principale 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 ADE. 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 az deployment group create comando . Quando si esegue questo comando all'interno del contenitore, scegliere un nome di distribuzione che non esegue l'override delle distribuzioni precedenti e usare i --no-prompt true flag e --only-show-errors per assicurarsi che la distribuzione non riesca in caso di avvisi o 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 Resource Manager vuoto, che rimuove tutte le risorse all'interno del gruppo di risorse ADE 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. AdE 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 ADE 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
Rendere l'immagine personalizzata accessibile ad AdE
È necessario compilare l'immagine Docker ed eseguirne il push nel registro contenitori per renderla disponibile per l'uso in ADE. È possibile compilare l'immagine usando l'interfaccia della riga di comando di Docker o usando uno script fornito da ADE.
Selezionare la scheda appropriata per altre informazioni su ogni approccio.
- Compilare l'immagine con l'interfaccia della riga di comando di Docker
- Creare un'immagine del contenitore con uno script
Prima di compilare l'immagine di cui eseguire il push nel registro, accertare che nel computer sia installato il motore Docker. 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
Eseguire il push dell'immagine Docker in un registro
Per usare le immagini personalizzate, è necessario configurare un registro di immagini accessibile pubblicamente con pull di immagini anonime abilitato. In questo modo, Ambienti di distribuzione di Azure può accedere all'immagine personalizzata da eseguire nel contenitore.
Registro Azure Container è un'offerta di Azure per archiviare immagini del contenitore e artefatti simili.
Per creare un registro, che si può effettuare tramite interfaccia della riga di comando di Azure, portale di Azure, comandi di PowerShell e altro ancora, scegliere un avvio rapido.
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 Azure per distribuire le risorse di Azure, vedere Aggiungere e configurare una definizione di ambiente.
Accedere ai log delle operazioni e ai dettagli degli errori
AdE archivia i dettagli dell'errore per una distribuzione non riuscita nel file $ADE_ERROR_LOG all'interno del contenitore.
Risolvere una distribuzione non riuscita:
Accedere al Portale per sviluppatori.
Identificare l'ambiente che ha restituito l’errore di distribuzione e selezionare Visualizza dettagli.
Esaminare i dettagli dell'errore nella sezione Dettagli errore.
Inoltre l'interfaccia della riga di comando di Azure consente di visualizzare i dettagli dell'errore di un ambiente tramite il comando seguente:
az devcenter dev environment show --environment-name {YOUR_ENVIRONMENT_NAME} --project {YOUR_PROJECT_NAME}
Per visualizzare i log delle operazioni per una distribuzione o un'eliminazione dell'ambiente, usare l'interfaccia della riga di comando di Azure e recuperare l'operazione più recente per l'ambiente, quindi visualizzare i log per tale ID operazione.
# Get list of operations on the environment, choose the latest operation
az devcenter dev environment list-operation --environment-name {YOUR_ENVIRONMENT_NAME} --project {YOUR_PROJECT_NAME}
# Using the latest operation ID, view the operation logs
az devcenter dev environment show-logs-by-operation --environment-name {YOUR_ENVIRONMENT_NAME} --project {YOUR_PROJECT_NAME} --operation-id {LATEST_OPERATION_ID}
Contenuto correlato
Commenti e suggerimenti
Presto disponibile: Nel corso del 2024 verranno gradualmente disattivati i problemi di GitHub come meccanismo di feedback per il contenuto e ciò verrà sostituito con un nuovo sistema di feedback. Per altre informazioni, vedere https://aka.ms/ContentUserFeedback.
Invia e visualizza il feedback per