Configuración de la imagen de contenedor para ejecutar implementaciones

Azure Deployment Environments (ADE) admite un modelo de extensibilidad que le permite configurar la definición del entorno con su marco de plantilla de IaC preferido. Puede almacenar imágenes personalizadas en un registro de contenedor, como Azure Container Registry (ACR) o Docker Hub y, a continuación, hacer referencia a ellas en las definiciones de entorno para implementar entornos.

En este artículo, aprenderá a crear imágenes de contenedor de Bicep personalizadas para implementar las definiciones de entorno en ADE. Aprenderá a usar una imagen estándar proporcionada por Microsoft o a configurar una infraestructura de aprovisionamiento de imágenes personalizada mediante el marco de infraestructura como código (IaC) de Bicep.

En este artículo, aprenderá a crear imágenes de contenedor personalizadas de Terraform para crear entornos de implementación con Azure Deployment Environments (ADE). Aprenderá a configurar una imagen personalizada para aprovisionar la infraestructura mediante el marco de infraestructura como código (IaC) de Terraform.

En este artículo, aprenderá a usar Pulumi para implementaciones en ADE. Aprenderá a usar una imagen estándar proporcionada por Pulumi o cómo configurar una imagen personalizada para aprovisionar la infraestructura mediante el marco Pulumi Infrastructure-as-Code (IaC).

Requisitos previos

• Una cuenta de Azure con una suscripción activa. Cree una cuenta gratuita.
• Azure Deployment Environments configurados en la suscripción de Azure.
  • Para configurar ADE, siga el Inicio rápido: configurar entornos de implementación de Azure.

Uso de imágenes de contenedor con ADE

Puede adoptar uno de los métodos siguientes para usar imágenes de contenedor con ADE:

• Use una imagen de contenedor estándar Para escenarios sencillos, use la imagen de contenedor ARM-Bicep estándar proporcionada por ADE.
• Crear una imagen de contenedor personalizada: para escenarios más complejos, cree una imagen de contenedor personalizada que cumpla sus requisitos específicos.

Use una imagen de contenedor estándar

ADE admite Azure Resource Manager (ARM) y Bicep sin necesidad de ninguna configuración adicional. Puede crear una definición de entorno que implemente recursos de Azure para un entorno de implementación agregando los archivos de plantilla (como azuredeploy.json y environment.yaml) al catálogo. ADE usa la imagen de contenedor ARM-Bicep estándar para crear el entorno de implementación.

En el archivo environment.yaml, la propiedad runner especifica la ubicación de la imagen de contenedor que desea usar. Para usar la imagen estándar publicada en el Registro de artefactos Microsoft, use los identificadores respectivos runner.

En el ejemplo siguiente se muestra un runner que hace referencia a la imagen de contenedor ARM-Bicep estándar:

    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

Puede ver la imagen de contenedor estándar de Bicep en el repositorio estándar de ADE en la carpeta Runner-Images para la imagen de ARM-Bicep .

Para más información sobre cómo crear definiciones de entorno que usen las imágenes de contenedor de ADE para implementar los recursos de Azure, consulte Incorporación y configuración de una definición de entorno.

Creación de una imagen de contenedor personalizada

Crear una imagen personalizada mediante un script

Crear una imagen de contenedor personalizada mediante un script

La creación de una imagen de contenedor personalizada le permite personalizar las implementaciones para que se ajusten a sus requisitos. Puede crear y compilar una imagen basada en la imagen estándar de ADE e insertarla en el registro de contenedor mediante un script de inicio rápido proporcionado por Microsoft. Puede encontrar el script en el repositorio de Deployment Environments. Para usar el script de inicio rápido, bifurque el repositorio y, a continuación, ejecute el script localmente.

El script compila la imagen y la inserta en una instancia específica de Azure Container Registry (ACR) en el repositorio "ade" con la etiqueta "latest". Este script requiere el nombre del registro y el directorio de la imagen personalizada, tener instalada la CLI de Azure y Docker Desktop y en las variables PATH, y requiere que tenga permisos para insertar en el registro especificado.

Para usar el script de inicio rápido para compilar e insertar rápidamente esta imagen de ejemplo en una instancia de Azure Container Registry, deberá:

• Bifurque este repositorio en su cuenta personal.
• Asegúrese de que la CLI de Azure y la aplicación Docker Desktop están instaladas en el equipo y en las variables PATH.
• Asegúrese de que tiene permisos para insertar imágenes en la instancia de Azure Container Registry seleccionada.

Para llamar al script, use el siguiente comando en PowerShell:

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

Además, si quiere insertar en un repositorio y un nombre de etiqueta específicos, puede ejecutar:

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

Para usar la imagen en las implementaciones de entorno, debe agregar la ubicación de la imagen al archivo de manifiesto Conectar la imagen a la definición del entorno y es posible que tenga que configurar permisos para que el ACR haga que la imagen personalizada esté disponible para ADE.

Crear una imagen personalizada manualmente

Creación manual de una imagen de contenedor personalizada

La creación de una imagen de contenedor personalizada le permite personalizar las implementaciones para que se ajusten a sus requisitos. Puede crear imágenes personalizadas basadas en las imágenes estándar de ADE.

Después de completar la personalización de la imagen, puede compilar la imagen e insertarla en el registro de contenedor manualmente.

Las imágenes personalizadas se crean mediante las imágenes estándar de ADE como base con la CLI de ADE, que está preinstalada en las imágenes estándar. Para obtener más información sobre la CLI de ADE, consulte la referencia de imagen de ejecutor personalizado de la CLI.

En este ejemplo, aprenderá a crear una imagen Docker para utilizar las implementaciones de ADE y acceder a la CLI de ADE, basando su imagen en una de las imágenes creadas por ADE.

Para crear una imagen configurada para ADE, siga estos pasos:

1. Cree una imagen personalizada basada en una imagen estándar.
2. Instale los paquetes deseados.
3. Configurar scripts de shell de operaciones.
4. Cree scripts de shell de operaciones para implementar plantillas de ARM o Bicep.

1. Cree una imagen personalizada basada en una imagen estándar

Cree un DockerFile que incluya una instrucción FROM que apunte a una imagen estándar hospedada en el Registro de artefactos Microsoft.

Esta es una instrucción FROM de ejemplo, que hace referencia a la imagen principal estándar:

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

Esta instrucción extrae la última imagen principal publicada y la convierte en base de la imagen personalizada.

2. Instalación de paquetes necesarios

En este paso, instalará los paquetes que necesite en la imagen, incluido Bicep. Puede instalar el paquete de Bicep con la CLI de Azure mediante la instrucción RUN, como se muestra en el siguiente ejemplo:

RUN az bicep install

Las imágenes estándar de ADE se basan en la imagen de la CLI de Azure y tienen preinstalados los paquetes de la CLI de ADE y JQ. Aquí puede obtener más información sobre la CLI de Azurey el paquete JQ.

Para instalar otros paquetes que necesite en la imagen, use la instrucción RUN.

3. Configuración de scripts de shell de operaciones

Dentro de las imágenes estándar, las operaciones se determinan y ejecutan en función del nombre de la operación. Actualmente, los dos nombres de operación admitidos son deploy y delete.

Para configurar la imagen personalizada de forma que use esta estructura, especifique una carpeta en el nivel de Dockerfile denominada scripts y especifique dos archivos, deploy.sh y delete.sh. El script del shell deploy se ejecuta al crear o volver a implementar el entorno y el script del shell delete se ejecuta al eliminar el entorno. Puede consultar ejemplos de scripts de shell en el repositorio bajo la carpeta Runner-Images para la imagen ARM-Bicep.

Para asegurarse de que estos scripts de shell sean ejecutables, agregue las siguientes líneas al Dockerfile:

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

4. Creación de scripts de shell de operaciones para implementar plantillas de ARM o Bicep

Para asegurarse de que puede implementar correctamente la infraestructura de ARM o Bicep a través de ADE, debe hacer lo siguiente:

1. Conversión de parámetros de ADE en parámetros aceptables para ARM
2. Resolución de plantillas vinculadas si se usan en la implementación
3. Uso de la identidad administrada con privilegios para realizar la implementación

Durante el punto de entrada de la imagen principal, los parámetros establecidos para el entorno actual se almacenan en la variable $ADE_OPERATION_PARAMETERS. Para convertirlos en parámetros aceptables para ARM, puede ejecutar el siguiente comando mediante 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) }' )

A continuación, para resolver cualquier plantilla vinculada utilizada dentro de una plantilla de ARM basada en JSON, puede descompilar el archivo de plantilla principal, que resuelve todos los archivos de infraestructura local utilizados en muchos módulos Bicep. A continuación, vuelva a compilar esos módulos en una única plantilla de ARM con las plantillas vinculadas insertadas en la plantilla de ARM principal como plantillas anidadas. Este paso solo es necesario durante la operación de implementación. El archivo de plantilla principal se puede especificar utilizando el $ADE_TEMPLATE_FILE establecido durante el punto de entrada de la imagen principal, y debe restablecer esta variable con el archivo de plantilla recompilado. Observe el ejemplo siguiente:

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

Para proporcionar los permisos que requiere una implementación para ejecutar la implementación y eliminación de recursos dentro de la suscripción, use la identidad administrada con privilegios asociada al tipo de entorno de proyecto de ADE. Si la implementación necesita permisos especiales para completarse, como roles concretos, asígnelos a la identidad del tipo de entorno del proyecto. A veces, la identidad administrada no está disponible inmediatamente al entrar en el contenedor; puede volver a intentarlo hasta que el inicio de sesión tenga éxito.

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

Para comenzar la implementación de las plantillas de ARM o Bicep, ejecute el comando az deployment group create. Al ejecutar este comando dentro del contenedor, elija un nombre de implementación que no invalide las implementaciones anteriores y use las marcas --no-prompt true y --only-show-errors para asegurarse de que la implementación no produce errores en ninguna advertencia o se detiene en la espera de la entrada del usuario, como se muestra en el siguiente ejemplo:

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

Para eliminar un entorno, realice una implementación en modo completo y proporcione una plantilla de ARM vacía, que quita todos los recursos del grupo de recursos de ADE especificado, como se muestra en el siguiente ejemplo:

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"

Para comprobar el estado de aprovisionamiento y los detalles, ejecute los siguientes comandos. ADE utiliza algunas funciones especiales para leer y proporcionar más contexto basado en los detalles de aprovisionamiento, que puede encontrar en la carpeta Runner-Images. Una implementación sencilla podría ser la siguiente:

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

Por último, para ver las salidas de la implementación y pasarlas a ADE para que sean accesibles a través de la CLI de Azure, puede ejecutar los siguientes comandos:

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

Compile la imagen personalizada

Puede compilar la imagen mediante la CLI de Docker. Asegúrese de que el Motor de Docker está instalado en el equipo. A continuación, vaya al directorio del Dockerfile y ejecute el siguiente comando:

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

Por ejemplo, si quiere guardar la imagen en un repositorio dentro del registro denominado customImage y cargar la versión de etiqueta de 1.0.0, debería ejecutar:

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

Uso de imágenes de contenedor con ADE

Puede adoptar uno de los métodos siguientes para usar imágenes de contenedor con ADE:

• Crear una imagen de contenedor personalizada mediante un script: use el script publicado para crear una imagen específica de Terraform.
• Crear una imagen de contenedor personalizada que aproveche un flujo de trabajo de GitHub: use el flujo de trabajo de GitHub publicado desde el repositorio Aprovechar el modelo de extensibilidad de ADE con Terraform.
• Creación manual de una imagen de contenedor personalizada: cree una imagen específica de Terraform personalizada manualmente.

Creación de una imagen de contenedor personalizada

Creación de una imagen mediante un script

Crear una imagen de contenedor personalizada mediante un script

La creación de una imagen de contenedor personalizada le permite personalizar las implementaciones para que se ajusten a sus requisitos. Puede crear una imagen basada en la imagen estándar de ADE e insertarla en el registro de contenedor mediante un script de inicio rápido proporcionado por Microsoft. Puede encontrar el script en el repositorio de Deployment Environments con Terraform. Para usar el script de inicio rápido, bifurque el repositorio y, a continuación, ejecute el script localmente.

Para usar el script de inicio rápido para compilar e insertar rápidamente esta imagen de ejemplo en una instancia de Azure Container Registry, deberá:

• Bifurque este repositorio en su cuenta personal.
• Asegúrese de que la CLI de Azure y la aplicación Docker Desktop están instaladas en el equipo y en las variables PATH.
• Asegúrese de que tiene permisos para insertar imágenes en la instancia de Azure Container Registry seleccionada.

El script compila la imagen y la inserta en una instancia específica de Azure Container Registry (ACR) en el repositorio "ade" con la etiqueta "latest". Este script requiere el nombre del registro y el directorio de la imagen personalizada, tener instalada la CLI de Azure y Docker Desktop y en las variables PATH, y requiere que tenga permisos para insertar en el registro especificado. Para llamar al script, use el siguiente comando en PowerShell:

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

Además, si quiere insertar en un repositorio y un nombre de etiqueta específicos, puede ejecutar:

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

Para usar la imagen en las implementaciones de entorno, debe agregar la ubicación de la imagen al archivo de manifiesto Conectar la imagen a la definición del entorno y es posible que tenga que configurar permisos para que el ACR haga que la imagen personalizada esté disponible para ADE.

Creación de una imagen mediante un flujo de trabajo de GitHub

Creación de una imagen de contenedor personalizada mediante un flujo de trabajo de GitHub

Para empezar, puede usar el flujo de trabajo de GitHub publicado desde el repositorio Aprovechamiento del modelo de extensibilidad de ADE con Terraform.

Para usar el flujo de trabajo, deberá hacer lo siguiente:

• Bifurcar este repositorio en su cuenta personal
• Permitir que Acciones de GitHub se conecte a Azure a través de las credenciales federadas de una aplicación de Microsoft Entra ID a través de OIDC. Puede encontrar más documentación sobre este proceso aquí
• Configure los secretos del repositorio para el repositorio que contenga el id. de aplicación de la aplicación de Microsoft Entra ID establecido como AZURE_CLIENT_ID, el id. de suscripción establecido como AZURE_SUBSCRIPTION_ID y el id. de inquilino establecido como AZURE_TENANT_ID
• Configure las variables de repositorio para el repositorio que contenga el nombre personal de Azure Container Registry (ACR) como REGISTRY_NAME, el nombre del repositorio preferido como REPOSITORY_NAME y la etiqueta preferida como TAG para la imagen creada. Puede modificar las variables entre ejecuciones de flujo de trabajo para insertar la imagen generada en registros, repositorios y etiquetas diferentes.

Ejecute el flujo de trabajo yendo a la pestaña Acciones del repositorio bifurcado y seleccione el flujo de trabajo que desea ejecutar. A continuación, puede seleccionar el botón Ejecutar flujo de trabajo para iniciar el flujo de trabajo.

Para usar la imagen en las implementaciones de entorno, debe agregar la ubicación de la imagen al archivo de manifiesto Conectar la imagen a la definición del entorno y es posible que tenga que configurar permisos para que el ACR haga que la imagen personalizada esté disponible para ADE.

Creación manual de una imagen

Creación manual de una imagen de contenedor personalizada

La creación de una imagen de contenedor personalizada le permite personalizar las implementaciones para que se ajusten a sus requisitos. Puede crear imágenes personalizadas basadas en las imágenes estándar de ADE.

Después de completar la personalización de la imagen, debe compilar la imagen e insertarla en el registro de contenedor.

Puede compilar e insertar la imagen manualmente o usar un script proporcionado por Microsoft para automatizar el proceso.

La acción de GitHub publicada ayuda a compilar e insertar una imagen en una instancia de Azure Container Registry (ACR). Puede hacer referencia a un vínculo de imagen de ACR proporcionado dentro de una definición de entorno en ADE para implementar o eliminar un entorno con la imagen proporcionada.

Para crear una imagen configurada para ADE, siga estos pasos:

1. Cree una imagen personalizada basada en un flujo de trabajo de GitHub.
2. Instale los paquetes deseados.
3. Configurar scripts de shell de operaciones.
4. Cree scripts de shell de operación que usen la CLI de Terraform.

1. Crear una imagen personalizada basada en un flujo de trabajo de GitHub

Use el repositorio publicado para aprovechar el flujo de trabajo de GitHub. El repositorio contiene componentes de imagen de ejemplo compatibles con ADE, incluidos scripts de Dockerfile y shell para implementar y eliminar entornos mediante plantillas de IaC de Terraform. Este código de ejemplo le ayuda a crear su propia imagen de contenedor.

2. Instale los paquetes necesarios En este paso, instalará los paquetes que necesite en la imagen, incluido Terraform. Puede instalar la CLI de Terraform en una ubicación ejecutable para que se pueda usar en los scripts de implementación y eliminación.

Este es un ejemplo de ese proceso, instalando la versión 1.7.5 de la CLI de 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

Sugerencia

Puede obtener la dirección URL de descarga de su versión preferida de la CLI de Terraform desde las versiones de Hashicorp.

3. Configuración de scripts de shell de operaciones

Dentro de las imágenes estándar, las operaciones se determinan y ejecutan en función del nombre de la operación. Actualmente, los dos nombres de operación admitidos son deploy y delete.

Para configurar la imagen personalizada de forma que use esta estructura, especifique una carpeta en el nivel de Dockerfile denominada scripts y especifique dos archivos, deploy.sh y delete.sh. El script del shell deploy se ejecuta al crear o volver a implementar el entorno y el script del shell delete se ejecuta al eliminar el entorno. Puede ver ejemplos de scripts de shell en el repositorio en la carpeta scripts para Terraform.

Para asegurarse de que estos scripts de shell sean ejecutables, agregue las siguientes líneas al Dockerfile:

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

4. Creación de scripts de shell de operaciones que usan la CLI de Terraform

Hay tres pasos para implementar la infraestructura mediante Terraform:

1. terraform init: inicializa la CLI de Terraform para realizar acciones en el directorio de trabajo
2. terraform plan: desarrolla un plan basado en los archivos y variables de infraestructura de Terraform entrantes, así como en los archivos de estado existentes, y desarrolla los pasos necesarios para crear o actualizar la infraestructura especificada en los archivos .tf
3. terraform apply: aplica el plan para crear una infraestructura existente o actualizarla en Azure

Durante el punto de entrada de la imagen principal, cualquier archivo de estado existente se introduce en el contenedor y el directorio se guarda bajo la variable de entorno $ADE_STORAGE. Además, los parámetros establecidos para el entorno actual almacenados en la variable $ADE_OPERATION_PARAMETERS. Para acceder al archivo de estado existente y establecer sus variables dentro de un archivo .tfvars.json, ejecute los siguientes comandos:

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

Además, para usar los privilegios de ADE para implementar la infraestructura dentro de su suscripción, su script necesita usar la Identidad de servicio administrada (MSI) al aprovisionar la infraestructura usando el proveedor de Terraform AzureRM. Si su implementación necesita permisos especiales para su finalización, como roles particulares, asigne esos permisos a la identidad del tipo de entorno del proyecto que se está usando para su implementación del entorno. ADE establece las variables de entorno pertinentes, como los id. de cliente, inquilino y suscripción dentro del punto de entrada de la imagen principal, así que ejecute los siguientes comandos para asegurarse de que el proveedor usa el MSI de ADE:

export ARM_USE_MSI=true
export ARM_CLIENT_ID=$ADE_CLIENT_ID
export ARM_TENANT_ID=$ADE_TENANT_ID
export ARM_SUBSCRIPTION_ID=$ADE_SUBSCRIPTION_ID

Si tiene otras variables a las que hacer referencia dentro de su plantilla que no estén especificadas en los parámetros de su entorno, establezca variables de entorno usando el prefijo TF_VAR. Se proporciona una lista de las variables de entorno de ADE proporcionadas referencia de variables de la CLI del entorno de implementación de Azure. Un ejemplo de esos comandos podría ser;

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

Ahora, puede ejecutar los pasos enumerados anteriormente para inicializar la CLI de Terraform, generar un plan para la infraestructura de aprovisionamiento y aplicar un plan durante el script de implementación:

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 el script de eliminación, puede agregar la marca destroy a la generación del plan para eliminar los recursos existentes, como se muestra en el ejemplo siguiente:

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

Por último, para que las salidas de la implementación se carguen y sean accesibles al acceder al entorno a través de la CLI de Azure, transforme el objeto de salida de Terraform al formato especificado por ADE mediante el paquete JQ. Establezca el valor en la variable de entorno $ADE_OUTPUTS, como se muestra en el ejemplo siguiente:

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

Compile la imagen personalizada

Puede compilar la imagen mediante la CLI de Docker. Asegúrese de que el Motor de Docker está instalado en el equipo. A continuación, vaya al directorio del Dockerfile y ejecute el siguiente comando:

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

Por ejemplo, si quiere guardar la imagen en un repositorio dentro del registro denominado customImage y cargar la versión de etiqueta de 1.0.0, debería ejecutar:

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

Use una imagen de contenedor estándar proporcionada por Pulumi

El equipo de Pulumi proporciona una imagen precompilada para empezar, que puede ver en la carpeta Runner-Image. Esta imagen está disponible públicamente en Docker Hub de Pulumi como pulumi/azure-deployment-environments, por lo que puede usarlo directamente desde las definiciones de entorno de ADE.

Este es un archivo de ejemplo environment.yaml que utiliza la imagen precompilada:

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

Puede encontrar algunas definiciones de entorno de ejemplo en la Carpeta entornos.

Crear una imagen personalizada

La creación de una imagen de contenedor personalizada le permite personalizar las implementaciones para que se ajusten a sus requisitos. Puede crear imágenes personalizadas basadas en las imágenes estándar Pulumi y personalizarlas para satisfacer sus requisitos. Después de completar la personalización de la imagen, debe compilar la imagen e insertarla en el registro de contenedor.

Para crear una imagen configurada para ADE, siga estos pasos:

1. Cree una imagen personalizada basada en una imagen estándar.
2. Instale los paquetes deseados.
3. Configurar scripts de shell de operaciones.
4. Cree scripts de shell de operación que usen la CLI de Pulumi.

1. Cree una imagen personalizada basada en una imagen estándar

Cree un DockerFile que incluya una instrucción FROM que apunte a una imagen estándar hospedada en el Registro de artefactos Microsoft.

Esta es una instrucción FROM de ejemplo, que hace referencia a la imagen principal estándar:

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

Esta instrucción extrae la última imagen principal publicada y la convierte en base de la imagen personalizada.

2. Instalación de paquetes necesarios

Puede instalar la CLI de Pulumi en una ubicación ejecutable para que se pueda usar en los scripts de implementación y eliminación.

Este es un ejemplo de ese proceso, instalando la versión más reciente de la CLI de Pulumi:

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

En función del lenguaje de programación que quiera usar para programas Pulumi, es posible que tenga que instalar uno o varios entornos de ejecución correspondientes. El entorno de ejecución de Python ya está disponible en la imagen base.

Este es un ejemplo de instalación de Node.js y TypeScript:

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

Las imágenes estándar de ADE se basan en la imagen de la CLI de Azure y tienen preinstalados los paquetes de la CLI de ADE y JQ. Aquí puede obtener más información sobre la CLI de Azurey el paquete JQ.

Para instalar otros paquetes que necesite en la imagen, use la instrucción RUN.

Hay cuatro pasos para implementar la infraestructura mediante Pulumi:

1. pulumi login : conéctese al almacenamiento de estado, ya sea en el sistema de archivos local o en Pulumi Cloud
2. pulumi stack select : cree o seleccione la pila que se va a usar para el entorno determinado
3. pulumi config set : se pasan los parámetros de implementación como valores de configuración de Pulumi
4. pulumi up : ejecute la implementación para crear una infraestructura existente o actualizarla en Azure

Durante el punto de entrada de la imagen principal, los archivos de estado local existentes se extraen en el contenedor y el directorio guardado en la variable de entorno $ADE_STORAGE. Para acceder al archivo de estado existente, ejecute los siguientes comandos:

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

Para iniciar sesión en Pulumi Cloud en su lugar, establezca el token de acceso de Pulumi como una variable de entorno y ejecute los comandos siguientes:

export PULUMI_ACCESS_TOKEN=YOUR_PULUMI_ACCESS_TOKEN
pulumi login

Los parámetros establecidos para el entorno actual se almacenan en la variable $ADE_OPERATION_PARAMETERS. Además, la región de Azure seleccionada y el nombre del grupo de recursos se pasan ADE_ENVIRONMENT_LOCATION y ADE_RESOURCE_GROUP_NAME respectivamente. Para establecer la configuración de la pila de Pulumi, ejecute los siguientes comandos:

# 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

Además, para usar privilegios de ADE para implementar la infraestructura dentro de la suscripción, el script debe usar ADE Managed Service Identity (MSI) al aprovisionar la infraestructura mediante el proveedor nativo de Azure Pulumi o Azure clásico. Si su implementación necesita permisos especiales para su finalización, como roles particulares, asigne esos permisos a la identidad del tipo de entorno del proyecto que se está usando para su implementación del entorno. ADE establece las variables de entorno pertinentes, como los identificadores de cliente, inquilino y suscripción dentro del punto de entrada de la imagen principal, por lo que ejecute los siguientes comandos para asegurarse de que el proveedor usa MSI de 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

Ahora, puede ejecutar el comando pulumi up para ejecutar la implementación:

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

Durante el script de eliminación, puede ejecutar el comando destroy, como se muestra en el ejemplo siguiente:

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

Por último, para que las salidas de la implementación se carguen y sean accesibles al acceder al entorno a través de la CLI de Azure, transforme el objeto de salida de Pulumi al formato especificado por ADE a través del paquete JQ. Establezca el valor en la variable de entorno $ADE_OUTPUTS, como se muestra en el ejemplo siguiente:

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

Compile la imagen personalizada

Puede compilar la imagen mediante la CLI de Docker. Asegúrese de que el Motor de Docker está instalado en el equipo. A continuación, vaya al directorio del Dockerfile y ejecute el siguiente comando:

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

Por ejemplo, si quiere guardar la imagen en un repositorio dentro del registro denominado customImage y cargar la versión de etiqueta de 1.0.0, debería ejecutar:

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

Hacer que la imagen personalizada esté disponible para ADE

Para usar imágenes personalizadas, debe almacenarlas en un registro de contenedor. Puede usar un registro de contenedor público o un registro de contenedor privado. Se recomienda encarecidamente Azure Container Registry (ACR), debido a su estrecha integración con ADE, la imagen se puede publicar sin permitir el acceso de extracción anónimo público. Debe compilar la imagen de contenedor personalizada e insertarla en un registro de contenedor para que esté disponible para su uso en ADE.

También es posible almacenar la imagen en un registro de contenedor diferente, como Docker Hub, pero en ese caso debe ser accesible públicamente.

Precaución

Almacenar la imagen de contenedor en un registro con acceso de extracción anónimo (sin autenticar) hace que sea accesible públicamente. No lo haga si la imagen contiene información confidencial. En su lugar, almacénela en Azure Container Registry (ACR) con el acceso de extracción anónimo deshabilitado.

Para usar una imagen personalizada almacenada en ACR, debe asegurarse de que ADE tiene los permisos adecuados para acceder a la imagen. Al crear una instancia de ACR, es segura de forma predeterminada y solo permite el acceso a usuarios autenticados.

Puede usar Pulumi para crear una instancia de Azure Container Registry y publicar la imagen en ella. Consulte el ejemplo de provisioning/custom-image para ver un proyecto Pulumi independiente que crea todos los recursos necesarios en su cuenta de Azure.

Seleccione la pestaña adecuada para obtener más información sobre cada enfoque.

Registro privado

Uso de un registro privado con acceso protegido

De forma predeterminada, el acceso a la extracción o inserción de contenido de una instancia de Azure Container Registry solo está disponible para los usuarios autenticados. Puede proteger aún más el acceso a ACR limitando el acceso desde determinadas redes y asignando roles específicos.

Para crear una instancia de ACR, lo cual puede realizarse mediante la CLI de Azure, Azure Portal o comandos de PowerShell entre otros métodos, siga uno de los inicios rápidos correspondientes.

Límite de acceso a la red

Para proteger el acceso de red a su ACR, puede limitar el acceso a sus propias redes o deshabilitar el acceso a la red pública por completo. Si limita el acceso a la red, debe habilitar la excepción de firewall Permitir que los servicios de Microsoft de confianza accedan a este registro de contenedor.

Para deshabilitar el acceso desde redes públicas:

1. Crear una instancia de ACR o usar una existente.

2. En Azure Portal, vaya al ACR que desea configurar.

3. En el menú de la izquierda, en Configuración, seleccione Redes.

4. En la página Redes, en la pestaña Acceso público, en Acceso a la red pública, seleccione Deshabilitado.

   

5. En Excepción firewall, compruebe que esta seleccionado Permitir que los servicios de Microsoft de confianza accedan a este registro de contenedor y, a continuación, seleccione Guardar.

   

Asignación del rol AcrPull

La creación de entornos mediante imágenes de contenedor usa la infraestructura de ADE, incluidos los proyectos y los tipos de entorno. Cada proyecto tiene uno o varios tipos de entorno de proyecto, que necesitan acceso de lectura a la imagen de contenedor que define el entorno que se va a implementar. Para acceder a las imágenes dentro de ACR de forma segura, asigne el rol AcrPull a cada tipo de entorno de proyecto.

Para asignar el rol AcrPull al tipo de entorno de proyecto:

1. En Azure Portal, vaya al ACR que desea configurar.

2. En el menú izquierdo, seleccione Access Control (IAM).

3. Seleccione Agregar>Agregar asignación de roles.

4. Asigne el siguiente rol. Para asignar roles, consulte Asignación de roles de Azure mediante Azure Portal.

   Configuración	Valor
   Rol	Seleccione AcrPull.
   Asignar acceso a	Seleccione Usuario, grupo o entidad de servicio.
   Miembros	Escriba el nombre del tipo de entorno del proyecto que necesita tener acceso a la imagen en el contenedor.

   El tipo de entorno de proyecto se muestra como en el ejemplo siguiente:

   

En esta configuración, ADE usa la identidad administrada para el PET, ya sea asignada por el sistema o por el usuario.

Sugerencia

Esta asignación de roles debe realizarse para cada tipo de entorno de proyecto. Se puede automatizar a través de la CLI de Azure.

Cuando esté listo para insertar la imagen en el registro, ejecute el siguiente comando:

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

Registro público

Uso de un registro público con extracción anónima

Para configurar el registro de forma que tenga habilitada la extracción anónima de imágenes, ejecute los siguientes comandos en la CLI de 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

Cuando esté listo para insertar la imagen en el registro, ejecute el siguiente comando:

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

Conexión de la imagen a la definición del entorno

Al crear definiciones de entorno para usar la imagen personalizada en su implementación, edite la propiedad runner en el archivo de manifiesto (environment.yaml o manifest.yaml).

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

Para más información sobre cómo crear definiciones de entorno que usen las imágenes de contenedor de ADE para implementar los recursos de Azure, consulte Incorporación y configuración de una definición de entorno.

Contenido relacionado

• Referencia de imagen de ejecutor personalizado de la CLI de ADE
• Referencia de variables de la CLI de ADE

• Repositorio azure-deployment-environments de Pulumi