Konfigurowanie obrazu kontenera do wykonywania wdrożeń

Z tego artykułu dowiesz się, jak tworzyć niestandardowe obrazy kontenerów Bicep w celu wdrożenia definicji środowiska w środowiskach wdrażania platformy Azure (ADE).

Z tego artykułu dowiesz się, jak utworzyć niestandardowe obrazy kontenerów programu Terraform w celu wdrożenia definicji środowiska w środowiskach wdrażania platformy Azure (ADE). Dowiesz się, jak skonfigurować obraz niestandardowy w celu aprowizacji infrastruktury przy użyciu platformy Terraform Infrastructure-as-Code (IaC).

Z tego artykułu dowiesz się, jak korzystać z programu Pulumi na potrzeby wdrożeń w środowiskach wdrażania platformy Azure (ADE). Dowiesz się, jak używać przykładowego obrazu dostarczonego przez firmę Pulumi lub jak skonfigurować obraz niestandardowy do aprowizacji infrastruktury przy użyciu platformy Pulumi Infrastructure-as-Code (IaC).

Program ADE obsługuje model rozszerzalności, który umożliwia tworzenie niestandardowych obrazów, których można używać w definicjach środowiska. Aby użyć tego modelu rozszerzalności, utwórz własne obrazy niestandardowe i zapisz je w rejestrze kontenerów, takim jak Azure Container Registry (ACR) lub Docker Hub. Następnie możesz odwoływać się do tych obrazów w definicjach środowiska w celu wdrożenia środowisk.

Definicja środowiska składa się z co najmniej dwóch plików: pliku szablonu, takiego jak azuredeploy.json lub main.bicep, oraz pliku manifestu o nazwie environment.yaml. Usługa ADE używa kontenerów do wdrażania definicji środowiska.

Zespół usługi ADE oferuje wybór obrazów, które ułatwiają rozpoczęcie pracy, w tym obraz podstawowy i obraz usługi Azure Resource Manager (ARM) — Bicep. Dostęp do tych przykładowych obrazów można uzyskać w folderze Runner-Images .

Definicja środowiska składa się z co najmniej dwóch plików: pliku szablonu, takiego jak main.tf, i pliku manifestu o nazwie environment.yaml. Kontener służy do wdrażania definicji środowiska korzystającej z programu Terraform.

Definicja środowiska składa się z co najmniej dwóch plików: pliku projektu Pulumi, Pulumi.yaml i pliku manifestu o nazwie environment.yaml. Może również zawierać program użytkownika napisany w preferowanym języku programowania: C#, TypeScript, Python itp. program ADE używa kontenerów do wdrażania definicji środowiska.

Wymagania wstępne

• Konto platformy Azure z aktywną subskrypcją. Utwórz konto bezpłatnie.
• Środowiska wdrażania platformy Azure skonfigurowane w ramach subskrypcji platformy Azure.
  • Aby skonfigurować usługę ADE, wykonaj czynności opisane w przewodniku Szybki start: Konfigurowanie środowisk wdrażania platformy Azure.

Używanie obrazów kontenerów z usługą ADE

Możesz użyć jednego z następujących metod używania obrazów kontenerów z usługą ADE:

• Użyj przykładowego obrazu kontenera w przypadku prostych scenariuszy, użyj przykładowego obrazu kontenera ARM-Bicep dostarczonego przez usługę ADE.
• Utwórz niestandardowy obraz kontenera W przypadku bardziej złożonych scenariuszy utwórz niestandardowy obraz kontenera spełniający określone wymagania.

Główne kroki, które należy wykonać podczas korzystania z obrazu kontenera, to:

1. Wybierz typ obrazu, którego chcesz użyć: przykładowy obraz lub obraz niestandardowy.
   • Jeśli używasz obrazu niestandardowego, zaczniesz od przykładowego obrazu, a następnie dostosujesz go do swoich wymagań.
2. Skompiluj obraz.
3. Przekaż obraz do rejestru prywatnego lub rejestru publicznego.
4. Skonfiguruj dostęp do rejestru.
   • W przypadku rejestru publicznego skonfiguruj anonimowe ściąganie.
   • W przypadku rejestru prywatnego nadaj uprawnienia usługi ACR centrum deweloperów.
5. Dodawanie lokalizacji obrazu do parametru runner w definicji środowiska
6. Wdróż środowiska korzystające z obrazu niestandardowego.

Pierwszym krokiem procesu jest wybranie typu obrazu, którego chcesz użyć. Wybierz odpowiednią kartę, aby wyświetlić proces.

Korzystanie z przykładowego obrazu kontenera

Korzystanie z przykładowego obrazu kontenera

Usługa ADE obsługuje usługi ARM i Bicep bez konieczności dodatkowej konfiguracji. Możesz utworzyć definicję środowiska, która wdraża zasoby platformy Azure dla środowiska wdrażania, dodając pliki szablonów (takie jak azuredeploy.json i environment.yaml) do katalogu. Usługa ADE następnie używa przykładowego obrazu kontenera ARM-Bicep do utworzenia środowiska wdrażania.

W pliku environment.yaml właściwość określa lokalizację obrazu kontenera, runner którego chcesz użyć. Aby użyć przykładowego obrazu opublikowanego na Rejestr Artefaktów Microsoft, użyj odpowiednich identyfikatorów runner.

W poniższym przykładzie pokazano, runner że odwołuje się do przykładowego obrazu kontenera ARM-Bicep:

    name: WebApp
    version: 1.0.0
    summary: Azure Web App Environment
    description: Deploys a web app in Azure without a datastore
    runner: Bicep
    templatePath: azuredeploy.json

Przykładowy obraz kontenera Bicep można zobaczyć w przykładowym repozytorium usługi ADE w folderze Runner-Images dla obrazu ARM-Bicep .

Aby uzyskać więcej informacji na temat tworzenia definicji środowiska, które używają obrazów kontenera ADE do wdrażania zasobów platformy Azure, zobacz Dodawanie i konfigurowanie definicji środowiska.

Użyj obrazu niestandardowego, aby skonfigurować obraz programu Terraform.

Używanie przykładowego obrazu kontenera dostarczonego przez aplikację Pulumi

Zespół Pulumi udostępnia wstępnie utworzony obraz umożliwiający rozpoczęcie pracy, który można zobaczyć w folderze Runner-Image . Ten obraz jest publicznie dostępny w usłudze Docker Hub firmy Pulumi jako pulumi/azure-deployment-environments, więc można go używać bezpośrednio z definicji środowiska ADE.

Oto przykładowy plik environment.yaml , który korzysta ze wstępnie utworzonego obrazu:

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

Kilka przykładowych definicji środowiska można znaleźć w folderze Środowiska.

Tworzenie obrazu niestandardowego

Tworzenie obrazu niestandardowego

Utworzenie niestandardowego obrazu kontenera umożliwia dostosowanie wdrożeń do własnych wymagań. Obrazy niestandardowe można tworzyć na podstawie przykładowych obrazów usługi ADE.

Po zakończeniu dostosowywania obrazu należy skompilować obraz i wypchnąć go do rejestru kontenerów.

Obraz można skompilować i wypchnąć ręcznie lub użyć skryptu dostarczonego przez firmę Microsoft w celu zautomatyzowania procesu.

Alternatywnie możesz utworzyć rozwidlenie repozytorium Korzystając z modelu rozszerzalności programu ADE za pomocą narzędzia Terraform, aby skompilować i wypchnąć obraz programu Terraform do dostarczonego usługi ACR.

Obrazy niestandardowe są kompilowane przy użyciu przykładowych obrazów usługi ADE jako podstawy z interfejsem wiersza polecenia programu ADE, który jest wstępnie zainstalowany na przykładowych obrazach. Aby dowiedzieć się więcej na temat interfejsu wiersza polecenia programu ADE, zobacz dokumentację niestandardowego modułu uruchamiającego interfejs wiersza polecenia.

W tym przykładzie dowiesz się, jak utworzyć obraz platformy Docker w celu korzystania z wdrożeń usługi ADE i uzyskiwania dostępu do interfejsu wiersza polecenia programu ADE, korzystając z obrazu z jednego z obrazów utworzonych przez program ADE.

Aby utworzyć obraz skonfigurowany dla usługi ADE, wykonaj następujące kroki:

1. Utwórz obraz niestandardowy na podstawie przykładowego obrazu.
2. Zainstaluj żądane pakiety.
3. Konfigurowanie skryptów powłoki operacji.
4. Tworzenie skryptów powłoki operacji w celu wdrożenia szablonów usługi ARM lub Bicep.

Aby utworzyć obraz skonfigurowany dla usługi ADE, wykonaj następujące kroki:

1. Utwórz obraz niestandardowy na podstawie przykładowego obrazu.
2. Zainstaluj żądane pakiety.
3. Konfigurowanie skryptów powłoki operacji.
4. Tworzenie skryptów powłoki operacji korzystających z interfejsu wiersza polecenia programu Terraform.

Aby utworzyć obraz skonfigurowany dla usługi ADE, wykonaj następujące kroki:

1. Utwórz obraz niestandardowy na podstawie przykładowego obrazu.
2. Zainstaluj żądane pakiety.
3. Konfigurowanie skryptów powłoki operacji.
4. Tworzenie skryptów powłoki operacji korzystających z interfejsu wiersza polecenia programu Pulumi.

1. Tworzenie obrazu niestandardowego na podstawie przykładowego obrazu

Utwórz plik DockerFile zawierający instrukcję FROM wskazującą przykładowy obraz hostowany na Rejestr Artefaktów Microsoft.

Oto przykładowa instrukcja FROM, odwołując się do przykładowego obrazu podstawowego:

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

Ta instrukcja ściąga ostatnio opublikowany obraz podstawowy i sprawia, że stanowi podstawę dla niestandardowego obrazu.

2. Zainstaluj wymagane pakiety

W tym kroku zainstalujesz wszystkie pakiety wymagane na obrazie, w tym Bicep. Pakiet Bicep można zainstalować za pomocą interfejsu wiersza polecenia platformy Azure przy użyciu instrukcji RUN, jak pokazano w poniższym przykładzie:

RUN az bicep install

W tym kroku zainstalujesz wszystkie pakiety wymagane na obrazie, w tym narzędzie Terraform. Interfejs wiersza polecenia programu Terraform można zainstalować w lokalizacji wykonywalnej, aby można było go użyć w skryptach wdrażania i usuwania.

Oto przykład tego procesu instalowania wersji 1.7.5 interfejsu wiersza polecenia narzędzia 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

Napiwek

Adres URL pobierania dla preferowanej wersji interfejsu wiersza polecenia narzędzia Terraform można pobrać z wersji programu Hashicorp.

Interfejs wiersza polecenia programu Pulumi można zainstalować w lokalizacji wykonywalnej, aby można było go użyć w skryptach wdrażania i usuwania.

Oto przykład tego procesu, instalując najnowszą wersję interfejsu wiersza polecenia pulumi:

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

W zależności od języka programowania, którego zamierzasz używać dla programów Pulumi, może być konieczne zainstalowanie co najmniej jednego odpowiedniego środowiska uruchomieniowego. Środowisko uruchomieniowe języka Python jest już dostępne w obrazie podstawowym.

Oto przykład instalowania Node.js i języka TypeScript:

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

Przykładowe obrazy usługi ADE są oparte na obrazie interfejsu wiersza polecenia platformy Azure i mają wstępnie zainstalowane pakiety JQ i interfejsu wiersza polecenia programu ADE. Możesz dowiedzieć się więcej na temat interfejsu wiersza polecenia platformy Azure i pakietu JQ.

Aby zainstalować więcej pakietów potrzebnych na obrazie, użyj instrukcji RUN.

3. Konfigurowanie skryptów powłoki operacji

W przykładowych obrazach operacje są określane i wykonywane na podstawie nazwy operacji. Obecnie dwie obsługiwane nazwy operacji są wdrażane i usuwane.

Aby skonfigurować obraz niestandardowy do korzystania z tej struktury, określ folder na poziomie pliku Dockerfile o nazwie scripts i określ dwa pliki, deploy.sh i delete.sh. Skrypt powłoki wdrażania jest uruchamiany po utworzeniu lub ponownym wdrożeniu środowiska, a skrypt powłoki usuwania jest uruchamiany po usunięciu środowiska. Przykłady skryptów powłoki można zobaczyć w repozytorium w folderze Runner-Images dla obrazu ARM-Bicep .

Aby upewnić się, że te skrypty powłoki są wykonywalne, dodaj następujące wiersze do pliku Dockerfile:

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

4. Tworzenie skryptów powłoki operacji w celu wdrożenia szablonów usługi ARM lub Bicep

Aby upewnić się, że możesz pomyślnie wdrożyć infrastrukturę ARM lub Bicep za pośrednictwem usługi ADE, musisz:

1. Konwertowanie parametrów usługi ADE na dopuszczalne parametry usługi ARM
2. Rozwiązywanie problemów z połączonymi szablonami, jeśli są one używane we wdrożeniu
3. Używanie tożsamości zarządzanej uprzywilejowanej do wykonania wdrożenia

Podczas punktu wejścia obrazu podstawowego wszystkie parametry ustawione dla bieżącego środowiska są przechowywane w zmiennej $ADE_OPERATION_PARAMETERS. Aby przekonwertować je na dopuszczalne parametry arm, można uruchomić następujące polecenie przy użyciu 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) }' )

Następnie, aby rozwiązać wszystkie połączone szablony używane w szablonie opartym na formacie JSON usługi ARM, można dekompilować główny plik szablonu, który rozwiązuje wszystkie lokalne pliki infrastruktury używane w wielu modułach Bicep. Następnie ponownie skompiluj te moduły w jeden szablon usługi ARM z połączonymi szablonami osadzonymi w głównym szablonie usługi ARM jako szablony zagnieżdżone. Ten krok jest niezbędny tylko podczas operacji wdrażania. Główny plik szablonu można określić przy użyciu zestawu podczas punktu wejścia obrazu podstawowego i należy zresetować tę zmienną przy użyciu $ADE_TEMPLATE_FILE ponownie skompilowanego pliku szablonu. Zobacz poniższy przykład:

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

Aby zapewnić uprawnienia do wdrożenia wymaga wykonania wdrożenia i usunięcia zasobów w ramach subskrypcji, użyj tożsamości zarządzanej uprzywilejowanej skojarzonej z typem środowiska projektu ADE. Jeśli wdrożenie wymaga specjalnych uprawnień do ukończenia, takich jak określone role, przypisz te role do tożsamości typu środowiska projektu. Czasami tożsamość zarządzana nie jest natychmiast dostępna podczas wprowadzania kontenera; Możesz ponowić próbę, dopóki logowanie nie powiedzie się.

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

Aby rozpocząć wdrażanie szablonów arm lub Bicep, uruchom az deployment group create polecenie . Podczas uruchamiania tego polecenia wewnątrz kontenera wybierz nazwę wdrożenia, która nie zastępuje żadnych poprzednich wdrożeń, i użyj --no-prompt true flag i --only-show-errors , aby upewnić się, że wdrożenie nie zakończy się niepowodzeniem na żadnych ostrzeżeniach lub zatrzymaniu w oczekiwaniu na dane wejściowe użytkownika, jak pokazano w poniższym przykładzie:

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

Aby usunąć środowisko, wykonaj wdrożenie w trybie pełnym i podaj pusty szablon usługi ARM, który usuwa wszystkie zasoby w określonej grupie zasobów programu ADE, jak pokazano w poniższym przykładzie:

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"

Stan aprowizacji i szczegóły można sprawdzić, uruchamiając poniższe polecenia. Usługa ADE używa niektórych specjalnych funkcji do odczytywania i udostępniania większego kontekstu na podstawie szczegółów aprowizacji, które można znaleźć w folderze Runner-Images . Prosta implementacja może być następująca:

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

Na koniec, aby wyświetlić dane wyjściowe wdrożenia i przekazać je do usługi ADE, aby były dostępne za pośrednictwem interfejsu wiersza polecenia platformy Azure, możesz uruchomić następujące polecenia:

deploymentOutput=$(az deployment group show -g "$ADE_RESOURCE_GROUP_NAME" -n "$deploymentName" --query properties.outputs)
if [ -z "$deploymentOutput" ]; then
    deploymentOutput="{}"
fi
echo "{\"outputs\": $deploymentOutput}" > $ADE_OUTPUTS

4. Tworzenie skryptów powłoki operacji korzystających z interfejsu wiersza polecenia narzędzia Terraform

Istnieją trzy kroki wdrażania infrastruktury za pomocą narzędzia Terraform:

1. terraform init — inicjuje interfejs wiersza polecenia narzędzia Terraform do wykonywania akcji w katalogu roboczym
2. terraform plan— opracowuje plan na podstawie przychodzących plików i zmiennych infrastruktury programu Terraform oraz wszelkich istniejących plików stanu oraz opracowuje kroki niezbędne do utworzenia lub zaktualizowania infrastruktury określonej w plikach tf
3. terraform apply — stosuje plan tworzenia nowej lub aktualizowania istniejącej infrastruktury na platformie Azure

Podczas punktu wejścia obrazu podstawowego wszystkie istniejące pliki stanu są pobierane do kontenera i katalogu zapisanego w zmiennej środowiskowej $ADE_STORAGE. Ponadto wszystkie parametry ustawione dla bieżącego środowiska przechowywanego w zmiennej $ADE_OPERATION_PARAMETERS. Aby uzyskać dostęp do istniejącego pliku stanu i ustawić zmienne w pliku .tfvars.json , uruchom następujące polecenia:

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

echo "$ADE_OPERATION_PARAMETERS" > $EnvironmentVars

Ponadto aby można było korzystać z uprawnień usługi ADE do wdrażania infrastruktury w ramach subskrypcji, skrypt musi używać tożsamości usługi zarządzanej (MSI) podczas aprowizacji infrastruktury przy użyciu dostawcy Programu Terraform AzureRM. Jeśli wdrożenie wymaga specjalnych uprawnień do ukończenia wdrożenia, takich jak określone role, przypisz te uprawnienia do tożsamości typu środowiska projektu, która jest używana na potrzeby wdrożenia środowiska. Program ADE ustawia odpowiednie zmienne środowiskowe, takie jak identyfikatory klienta, dzierżawy i subskrypcji w punkcie wejścia podstawowego obrazu, dlatego uruchom następujące polecenia, aby upewnić się, że dostawca korzysta z tożsamości usługi 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

Jeśli masz inne zmienne do odwoływania się do szablonu, które nie są określone w parametrach środowiska, ustaw zmienne środowiskowe przy użyciu prefiksu TF_VAR. Lista udostępnionych zmiennych środowiskowych usługi ADE jest udostępniana dokumentacja zmiennych interfejsu wiersza polecenia środowiska wdrażania platformy Azure. Przykładem tych poleceń może być:

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

Teraz możesz uruchomić kroki wymienione wcześniej, aby zainicjować interfejs wiersza polecenia programu Terraform, wygenerować plan aprowizacji infrastruktury i zastosować plan podczas skryptu wdrażania:

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

Podczas skryptu usuwania można dodać flagę destroy do generacji planu, aby usunąć istniejące zasoby, jak pokazano w poniższym przykładzie:

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

Na koniec, aby dane wyjściowe wdrożenia zostały przekazane i dostępne podczas uzyskiwania dostępu do środowiska za pośrednictwem interfejsu wiersza polecenia platformy Azure, przekształć obiekt wyjściowy z programu Terraform do formatu określonego przez program ADE za pomocą pakietu JQ. Ustaw wartość na zmienną środowiskową $ADE_OUTPUTS, jak pokazano w poniższym przykładzie:

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

Istnieją cztery kroki wdrażania infrastruktury za pośrednictwem aplikacji Pulumi:

1. pulumi login — nawiąż połączenie z magazynem stanu w lokalnym systemie plików lub w usłudze Pulumi Cloud
2. pulumi stack select — tworzenie lub wybieranie stosu do użycia dla określonego środowiska
3. pulumi config set — przekazywanie parametrów wdrożenia jako wartości konfiguracji aplikacji Pulumi
4. pulumi up — uruchamianie wdrożenia w celu utworzenia nowej lub aktualizacji istniejącej infrastruktury na platformie Azure

Podczas punktu wejścia obrazu podstawowego wszystkie istniejące pliki stanu lokalnego są pobierane do kontenera i katalogu zapisanego w zmiennej środowiskowej $ADE_STORAGE. Aby uzyskać dostęp do istniejącego pliku stanu, uruchom następujące polecenia:

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

Aby zalogować się do usługi Pulumi Cloud, ustaw token dostępu pulumi jako zmienną środowiskową i uruchom następujące polecenia:

export PULUMI_ACCESS_TOKEN=YOUR_PULUMI_ACCESS_TOKEN
pulumi login

Wszystkie parametry ustawione dla bieżącego środowiska są przechowywane w zmiennej $ADE_OPERATION_PARAMETERS. Ponadto wybrana nazwa regionu i grupy zasobów platformy Azure jest przekazywana odpowiednio i ADE_ENVIRONMENT_LOCATION ADE_RESOURCE_GROUP_NAME . Aby ustawić konfigurację stosu Pulumi, uruchom następujące polecenia:

# 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

Ponadto aby można było korzystać z uprawnień usługi ADE do wdrażania infrastruktury w ramach subskrypcji, skrypt musi używać tożsamości usługi zarządzanej (MSI) programu ADE podczas aprowizacji infrastruktury przy użyciu natywnego dla platformy Azure programu Pulumi lub klasycznego dostawcy platformy Azure. Jeśli wdrożenie wymaga specjalnych uprawnień do ukończenia wdrożenia, takich jak określone role, przypisz te uprawnienia do tożsamości typu środowiska projektu, która jest używana na potrzeby wdrożenia środowiska. Program ADE ustawia odpowiednie zmienne środowiskowe, takie jak identyfikatory klienta, dzierżawy i subskrypcji w punkcie wejścia obrazu podstawowego, dlatego uruchom następujące polecenia, aby upewnić się, że dostawca korzysta z tożsamości usługi 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

Teraz możesz uruchomić pulumi up polecenie , aby wykonać wdrożenie:

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

Podczas skryptu destroy usuwania możesz zamiast tego uruchomić polecenie, jak pokazano w poniższym przykładzie:

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

Na koniec, aby dane wyjściowe wdrożenia były przekazywane i dostępne podczas uzyskiwania dostępu do środowiska za pośrednictwem interfejsu wiersza polecenia platformy Azure, przekształć obiekt wyjściowy z aplikacji Pulumi do formatu określonego przez program ADE za pomocą pakietu JQ. Ustaw wartość na zmienną środowiskową $ADE_OUTPUTS, jak pokazano w poniższym przykładzie:

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

Kompilowanie obrazu

Obraz można utworzyć przy użyciu interfejsu wiersza polecenia platformy Docker. Upewnij się, że aparat platformy Docker jest zainstalowany na komputerze. Następnie przejdź do katalogu pliku Dockerfile i uruchom następujące polecenie:

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

Jeśli na przykład chcesz zapisać obraz w repozytorium w rejestrze o nazwie customImage, i przekazać go przy użyciu wersji tagu 1.0.0, uruchom następujące polecenie:

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

Udostępnianie obrazu niestandardowego usłudze ADE

Aby można było używać obrazów niestandardowych, należy je przechowywać w rejestrze kontenerów. Można użyć publicznego rejestru kontenerów lub prywatnego rejestru kontenerów. Usługa Azure Container Registry (ACR) jest zdecydowanie zalecana ze względu na ścisłą integrację z usługą ADE, obraz można opublikować bez zezwalania na publiczny anonimowy dostęp do ściągania. Musisz skompilować niestandardowy obraz kontenera i wypchnąć go do rejestru kontenerów, aby udostępnić go do użycia w usłudze ADE.

Można również przechowywać obraz w innym rejestrze kontenerów, takim jak Docker Hub, ale w takim przypadku musi być publicznie dostępny.

Uwaga

Przechowywanie obrazu kontenera w rejestrze z dostępem do ściągnięcia anonimowego (nieuwierzytelnionego) sprawia, że jest on publicznie dostępny. Nie należy tego robić, jeśli obraz zawiera jakiekolwiek poufne informacje. Zamiast tego zapisz go w usłudze Azure Container Registry (ACR) z wyłączonym anonimowym dostępem do ściągania.

Aby użyć obrazu niestandardowego przechowywanego w usłudze ACR, należy upewnić się, że usługa ADE ma odpowiednie uprawnienia dostępu do obrazu. Podczas tworzenia wystąpienia usługi ACR jest ono domyślnie bezpieczne i zezwala tylko uwierzytelnieni użytkownikom na uzyskiwanie dostępu.

Za pomocą aplikacji Pulumi możesz utworzyć usługę Azure Container Registry i opublikować w niej obraz. Zapoznaj się z przykładem aprowizacji/niestandardowego obrazu dla samodzielnego projektu Pulumi, który tworzy wszystkie wymagane zasoby na koncie platformy Azure.

Wybierz odpowiednią kartę, aby dowiedzieć się więcej o każdym podejściu.

Rejestr prywatny

Używanie rejestru prywatnego z zabezpieczonym dostępem

Domyślnie dostęp do ściągania lub wypychania zawartości z usługi Azure Container Registry jest dostępny tylko dla uwierzytelnionych użytkowników. Możesz dodatkowo zabezpieczyć dostęp do usługi ACR, ograniczając dostęp z określonych sieci i przypisując określone role.

Aby utworzyć wystąpienie usługi ACR, które można wykonać za pomocą interfejsu wiersza polecenia platformy Azure, witryny Azure Portal, poleceń programu PowerShell i nie tylko, postępuj zgodnie z jednym z przewodników Szybki start.

Ograniczanie dostępu do sieci

Aby zabezpieczyć dostęp sieciowy do usługi ACR, możesz ograniczyć dostęp do własnych sieci lub całkowicie wyłączyć dostęp do sieci publicznej. W przypadku ograniczenia dostępu do sieci należy włączyć wyjątek zapory Zezwalaj na dostęp do tego rejestru kontenerów zaufanym usługi firmy Microsoft.

Aby wyłączyć dostęp z sieci publicznych:

1. Utwórz wystąpienie usługi ACR lub użyj istniejącego wystąpienia.

2. W witrynie Azure Portal przejdź do usługi ACR, którą chcesz skonfigurować.

3. W menu po lewej stronie w obszarze Ustawienia wybierz pozycję Sieć.

4. Na stronie Sieć na karcie Dostęp publiczny w obszarze Dostęp publiczny wybierz pozycję Wyłączone.

   

5. W obszarze Wyjątek zapory zaznacz pole wyboru Zezwalaj na dostęp do tego rejestru kontenerów za pomocą zaufanych usługi firmy Microsoft, a następnie wybierz pozycję Zapisz.

   

Przypisywanie roli AcrPull

Tworzenie środowisk przy użyciu obrazów kontenerów korzysta z infrastruktury usługi ADE, w tym projektów i typów środowisk. Każdy projekt ma co najmniej jeden typ środowiska projektu, który wymaga dostępu do odczytu do obrazu kontenera, który definiuje środowisko do wdrożenia. Aby bezpiecznie uzyskać dostęp do obrazów w usłudze ACR, przypisz rolę AcrPull do każdego typu środowiska projektu.

Aby przypisać rolę AcrPull do typu środowiska projektu:

1. W witrynie Azure Portal przejdź do usługi ACR, którą chcesz skonfigurować.

2. W menu po lewej stronie wybierz pozycję Kontrola dostępu (Zarządzanie dostępem i tożsamościami).

3. Wybierz pozycję Dodaj>Dodaj przypisanie roli.

4. Przypisz następującą rolę. Aby uzyskać szczegółowe instrukcje, zobacz Przypisywanie ról platformy Azure przy użyciu witryny Azure Portal.

   Ustawienie	Wartość
   Rola	Wybierz pozycję AcrPull.
   Przypisywanie dostępu do	Wybierz pozycję Użytkownik, grupa lub jednostka usługi.
   Elementy członkowskie	Wprowadź nazwę typu środowiska projektu, który musi uzyskać dostęp do obrazu w kontenerze.

   Typ środowiska projektu jest wyświetlany jak w poniższym przykładzie:

   

W tej konfiguracji usługa ADE używa tożsamości zarządzanej dla konta PET, niezależnie od tego, czy przypisano system, czy przypisano użytkownika.

Napiwek

To przypisanie roli musi zostać wykonane dla każdego typu środowiska projektu. Można ją zautomatyzować za pomocą interfejsu wiersza polecenia platformy Azure.

Gdy wszystko będzie gotowe do wypchnięcia obrazu do rejestru, uruchom następujące polecenie:

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

Rejestr publiczny

Używanie rejestru publicznego z anonimowym ściąganiem

Aby skonfigurować rejestr w celu włączenia ściągania anonimowego obrazu, uruchom następujące polecenia w interfejsie wiersza polecenia platformy 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

Gdy wszystko będzie gotowe do wypchnięcia obrazu do rejestru, uruchom następujące polecenie:

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

Tworzenie obrazu kontenera za pomocą skryptu

Zamiast tworzyć obraz niestandardowy i wypychać go do rejestru kontenerów samodzielnie, możesz użyć skryptu do skompilowania i wypchnięcia go do określonego rejestru kontenerów.

Firma Microsoft udostępnia skrypt szybkiego startu, który ułatwia tworzenie obrazu niestandardowego i wypychanie go do rejestru. Skrypt kompiluje obraz i wypycha go do określonej usługi Azure Container Registry (ACR) w repozytorium ade i tagu latest.

Aby użyć skryptu, musisz:

1. Utwórz folder Dockerfile i scripts, aby obsługiwać model rozszerzalności usługi ADE.
2. Podaj nazwę rejestru i katalog dla obrazu niestandardowego.
3. Zainstaluj interfejs wiersza polecenia platformy Azure i program Docker Desktop oraz w zmiennych PATH.
4. Ma uruchomiony program Docker Desktop.
5. Mieć uprawnienia do wypychania do określonego rejestru.

Skrypt można wyświetlić tutaj.

Skrypt można wywołać przy użyciu następującego polecenia w programie PowerShell:

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

Ponadto jeśli chcesz wypchnąć do określonego repozytorium i nazwy tagu, możesz uruchomić następujące polecenie:

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

Łączenie obrazu z definicją środowiska

Podczas tworzenia definicji środowiska do używania obrazu niestandardowego we wdrożeniu edytuj runner właściwość w pliku manifestu (environment.yaml lub manifest.yaml).

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

Aby dowiedzieć się więcej na temat tworzenia definicji środowiska, które używają obrazów kontenera usługi ADE do wdrażania zasobów platformy Azure, zobacz Dodawanie i konfigurowanie definicji środowiska.

Powiązana zawartość

• Dokumentacja niestandardowego modułu uruchamiającego interfejsu wiersza polecenia programu ADE
• Dokumentacja zmiennych interfejsu wiersza polecenia programu ADE

• Repozytorium azure-deployment-environments pulumi