Jak korzystać z publicznej zawartości i utrzymywać je za pomocą zadań Azure Container Registry

Artykuł
10/31/2023

Ten artykuł zawiera przykładowy przepływ pracy w Azure Container Registry, aby ułatwić zarządzanie korzystaniem z zawartości publicznej i konserwowania jej:

Zaimportuj lokalne kopie zależnych obrazów publicznych.
Weryfikowanie obrazów publicznych za pomocą skanowania zabezpieczeń i testowania funkcjonalnego.
Podwyższ poziom obrazów do prywatnych rejestrów w celu użycia wewnętrznego.
Wyzwalanie aktualizacji obrazu podstawowego dla aplikacji zależnych od zawartości publicznej.
Użyj Azure Container Registry Tasks, aby zautomatyzować ten przepływ pracy.

Przepływ pracy jest podsumowany na poniższej ilustracji:

Korzystanie z przepływu pracy zawartości publicznej

Przepływ pracy importowania z bramą pomaga zarządzać zależnościami organizacji na artefaktach zarządzanych zewnętrznie — na przykład obrazy pochodzące z publicznych rejestrów, takich jak Docker Hub, GCR, Quay, GitHub Container Registry, Microsoft Container Registry, a nawet inne rejestry kontenerów platformy Azure.

Aby zapoznać się z informacjami na temat zagrożeń wprowadzonych przez zależności dotyczące zawartości publicznej i sposobu używania Azure Container Registry w celu ich ograniczenia, zobacz wpis w blogu OCI Consuming Public Content (Korzystanie z zawartości publicznej) i Zarządzanie zawartością publiczną za pomocą Azure Container Registry.

Aby ukończyć ten przewodnik, możesz użyć usługi Azure Cloud Shell lub lokalnej instalacji interfejsu wiersza polecenia platformy Azure. Zalecane jest użycie interfejsu wiersza polecenia platformy Azure w wersji 2.10 lub nowszej. Jeśli konieczna będzie instalacja lub uaktualnienie, zobacz Instalowanie interfejsu wiersza polecenia platformy Azure.

Omówienie scenariusza

importowanie składników przepływu pracy

Ten przewodnik konfiguruje:

Trzy rejestry kontenerów reprezentujące:
- Symulowana Docker Hub (publicregistry) do obsługi zmiany obrazu podstawowego
- Rejestr zespołu (contoso) umożliwiający udostępnianie obrazów prywatnych
- Rejestr udostępniony firmy/zespołu (baseartifacts) dla zaimportowanych zawartości publicznej
Zadanie usługi ACR w każdym rejestrze. Zadania:
1. Tworzenie symulowanego obrazu publicznego node
2. Importowanie i weryfikowanie node obrazu w rejestrze udostępnionym firmy/zespołu
3. Kompilowanie i wdrażanie hello-world obrazu
Definicje zadań usługi ACR, w tym konfiguracje dla:
Kolekcja poświadczeń rejestru, które są wskaźnikami do magazynu kluczy
Kolekcja wpisów tajnych dostępnych w obiekcie acr-task.yaml, które są wskaźnikami do magazynu kluczy
Kolekcja skonfigurowanych wartości używanych w obiekcie acr-task.yaml
Magazyn kluczy platformy Azure do zabezpieczania wszystkich wpisów tajnych
Wystąpienie kontenera platformy Azure, które hostuje aplikację kompilacji hello-world

Wymagania wstępne

Poniższe kroki umożliwiają skonfigurowanie wartości dla zasobów utworzonych i użytych w przewodniku.

Ustawianie zmiennych środowiskowych

Skonfiguruj zmienne unikatowe dla danego środowiska. Stosujemy najlepsze rozwiązania dotyczące umieszczania zasobów z trwałą zawartością we własnej grupie zasobów w celu zminimalizowania przypadkowego usunięcia. Można je jednak umieścić w jednej grupie zasobów w razie potrzeby.

Przykłady w tym artykule są sformatowane dla powłoki powłoki bash.

# Set the three registry names, must be globally unique:
REGISTRY_PUBLIC=publicregistry
REGISTRY_BASE_ARTIFACTS=contosobaseartifacts
REGISTRY=contoso

# set the location all resources will be created in:
RESOURCE_GROUP_LOCATION=eastus

# default resource groups
REGISTRY_PUBLIC_RG=${REGISTRY_PUBLIC}-rg
REGISTRY_BASE_ARTIFACTS_RG=${REGISTRY_BASE_ARTIFACTS}-rg
REGISTRY_RG=${REGISTRY}-rg

# fully qualified registry urls
REGISTRY_DOCKERHUB_URL=docker.io
REGISTRY_PUBLIC_URL=${REGISTRY_PUBLIC}.azurecr.io
REGISTRY_BASE_ARTIFACTS_URL=${REGISTRY_BASE_ARTIFACTS}.azurecr.io
REGISTRY_URL=${REGISTRY}.azurecr.io

# Azure key vault for storing secrets, name must be globally unique
AKV=acr-task-credentials
AKV_RG=${AKV}-rg

# ACI for hosting the deployed application
ACI=hello-world-aci
ACI_RG=${ACI}-rg

Repozytoria Git i tokeny

Aby zasymulować środowisko, rozwidlenie każdego z następujących repozytoriów Git w repozytoriach, którymi można zarządzać.

Następnie zaktualizuj następujące zmienne dla rozwidlonych repozytoriów.

Dołączona :main na końcu adresów URL usługi Git reprezentuje domyślną gałąź repozytorium.

GIT_BASE_IMAGE_NODE=https://github.com/<your-fork>/base-image-node.git#main
GIT_NODE_IMPORT=https://github.com/<your-fork>/import-baseimage-node.git#main
GIT_HELLO_WORLD=https://github.com/<your-fork>/hello-world.git#main

Do klonowania i ustanawiania elementów webhook usługi GitHub potrzebny jest token dostępu usługi GitHub (PAT). Aby uzyskać instrukcje tworzenia tokenu z wymaganymi uprawnieniami do prywatnego repozytorium, zobacz Tworzenie tokenu dostępu usługi GitHub.

GIT_TOKEN=<set-git-token-here>

poświadczenia Docker Hub

Aby uniknąć ograniczania przepływności i żądań tożsamości podczas ściągania obrazów z Docker Hub, utwórz token Docker Hub. Następnie ustaw następujące zmienne środowiskowe:

REGISTRY_DOCKERHUB_USER=<yourusername>
REGISTRY_DOCKERHUB_PASSWORD=<yourtoken>

Tworzenie rejestrów

Za pomocą poleceń interfejsu wiersza polecenia platformy Azure utwórz trzy rejestry kontenerów w warstwie Premium, z których każda ma własną grupę zasobów:

az group create --name $REGISTRY_PUBLIC_RG --location $RESOURCE_GROUP_LOCATION
az acr create --resource-group $REGISTRY_PUBLIC_RG --name $REGISTRY_PUBLIC --sku Premium

az group create --name $REGISTRY_BASE_ARTIFACTS_RG --location $RESOURCE_GROUP_LOCATION
az acr create --resource-group $REGISTRY_BASE_ARTIFACTS_RG --name $REGISTRY_BASE_ARTIFACTS --sku Premium

az group create --name $REGISTRY_RG --location $RESOURCE_GROUP_LOCATION
az acr create --resource-group $REGISTRY_RG --name $REGISTRY --sku Premium

Tworzenie magazynu kluczy i ustawianie wpisów tajnych

Utwórz magazyn kluczy:

az group create --name $AKV_RG --location $RESOURCE_GROUP_LOCATION
az keyvault create --resource-group $AKV_RG --name $AKV

Ustaw nazwę użytkownika i token Docker Hub w magazynie kluczy:

az keyvault secret set \
--vault-name $AKV \
--name registry-dockerhub-user \
--value $REGISTRY_DOCKERHUB_USER

az keyvault secret set \
--vault-name $AKV \
--name registry-dockerhub-password \
--value $REGISTRY_DOCKERHUB_PASSWORD

Ustaw i zweryfikuj identyfikator PAT usługi Git w magazynie kluczy:

az keyvault secret set --vault-name $AKV --name github-token --value $GIT_TOKEN

az keyvault secret show --vault-name $AKV --name github-token --query value -o tsv

Tworzenie grupy zasobów dla wystąpienia kontenera platformy Azure

Ta grupa zasobów jest używana w późniejszym zadaniu podczas wdrażania hello-world obrazu.

az group create --name $ACI_RG --location $RESOURCE_GROUP_LOCATION

Tworzenie publicznego obrazu podstawowego `node`

Aby zasymulować node obraz na Docker Hub, utwórz zadanie usługi ACR w celu skompilowania i utrzymania obrazu publicznego. Ta konfiguracja umożliwia symulowanie zmian przez osoby odpowiedzialne za node obraz.

az acr task create \
  --name node-public \
  -r $REGISTRY_PUBLIC \
  -f acr-task.yaml \
  --context $GIT_BASE_IMAGE_NODE \
  --git-access-token $(az keyvault secret show \
                        --vault-name $AKV \
                        --name github-token \
                        --query value -o tsv) \
  --set REGISTRY_FROM_URL=${REGISTRY_DOCKERHUB_URL}/ \
  --assign-identity

Aby uniknąć ograniczania przepustowości platformy Docker, dodaj Docker Hub poświadczenia do zadania. Za pomocą polecenia acr task credentials można przekazać poświadczenia platformy Docker do dowolnego rejestru, w tym Docker Hub.

az acr task credential add \
  -n node-public \
  -r $REGISTRY_PUBLIC \
  --login-server $REGISTRY_DOCKERHUB_URL \
  -u https://${AKV}.vault.azure.net/secrets/registry-dockerhub-user \
  -p https://${AKV}.vault.azure.net/secrets/registry-dockerhub-password \
  --use-identity [system]

Udziel zadania dostępu do odczytu wartości z magazynu kluczy:

az keyvault set-policy \
  --name $AKV \
  --resource-group $AKV_RG \
  --object-id $(az acr task show \
                  --name node-public \
                  --registry $REGISTRY_PUBLIC \
                  --query identity.principalId --output tsv) \
  --secret-permissions get

Zadania można wyzwalać za pomocą zatwierdzeń usługi Git, aktualizacji obrazu podstawowego, czasomierzy lub przebiegów ręcznych.

Uruchom zadanie ręcznie, aby wygenerować node obraz:

az acr task run -r $REGISTRY_PUBLIC -n node-public

Wyświetl obraz w symulowanym rejestrze publicznym:

az acr repository show-tags -n $REGISTRY_PUBLIC --repository node

`hello-world` Tworzenie obrazu

Na podstawie symulowanego obrazu publicznego node skompiluj hello-world obraz.

Tworzenie tokenu na potrzeby dostępu ściągnięcia do symulowanego rejestru publicznego

Utwórz token dostępu do symulowanego rejestru publicznego z zakresem pull. Następnie ustaw go w magazynie kluczy:

az keyvault secret set \
  --vault-name $AKV \
  --name "registry-${REGISTRY_PUBLIC}-user" \
  --value "registry-${REGISTRY_PUBLIC}-user"

az keyvault secret set \
  --vault-name $AKV \
  --name "registry-${REGISTRY_PUBLIC}-password" \
  --value $(az acr token create \
              --name "registry-${REGISTRY_PUBLIC}-user" \
              --registry $REGISTRY_PUBLIC \
              --scope-map _repositories_pull \
              -o tsv \
              --query credentials.passwords[0].value)

Tworzenie tokenu na potrzeby dostępu ściągnięcia przez Azure Container Instances

Utwórz token dostępu do rejestru hostowania hello-world obrazu o określonym zakresie w celu ściągnięcia. Następnie ustaw go w magazynie kluczy:

az keyvault secret set \
  --vault-name $AKV \
  --name "registry-${REGISTRY}-user" \
  --value "registry-${REGISTRY}-user"

az keyvault secret set \
  --vault-name $AKV \
  --name "registry-${REGISTRY}-password" \
  --value $(az acr token create \
              --name "registry-${REGISTRY}-user" \
              --registry $REGISTRY \
              --repository hello-world content/read \
              -o tsv \
              --query credentials.passwords[0].value)

Tworzenie zadania do kompilowania i obsługi `hello-world` obrazu

Następujące polecenie tworzy zadanie z definicji w acr-tasks.yamlhello-world repozytorium. Kroki zadania kompilują hello-world obraz, a następnie wdrażają go w Azure Container Instances. Grupa zasobów dla Azure Container Instances została utworzona w poprzedniej sekcji. Wywołując w zadaniu tylko różnicę w image:tagelemecie az container create , zadanie jest wdrażane w tym samym wystąpieniu w tym przewodniku.

az acr task create \
  -n hello-world \
  -r $REGISTRY \
  -f acr-task.yaml \
  --context $GIT_HELLO_WORLD \
  --git-access-token $(az keyvault secret show \
                        --vault-name $AKV \
                        --name github-token \
                        --query value -o tsv) \
  --set REGISTRY_FROM_URL=${REGISTRY_PUBLIC_URL}/ \
  --set KEYVAULT=$AKV \
  --set ACI=$ACI \
  --set ACI_RG=$ACI_RG \
  --assign-identity

Dodaj poświadczenia do zadania dla symulowanego rejestru publicznego:

az acr task credential add \
  -n hello-world \
  -r $REGISTRY \
  --login-server $REGISTRY_PUBLIC_URL \
  -u https://${AKV}.vault.azure.net/secrets/registry-${REGISTRY_PUBLIC}-user \
  -p https://${AKV}.vault.azure.net/secrets/registry-${REGISTRY_PUBLIC}-password \
  --use-identity [system]

Udziel zadania dostępu do odczytu wartości z magazynu kluczy:

az keyvault set-policy \
  --name $AKV \
  --resource-group $AKV_RG \
  --object-id $(az acr task show \
                  --name hello-world \
                  --registry $REGISTRY \
                  --query identity.principalId --output tsv) \
  --secret-permissions get

Udziel zadania dostępu do tworzenia Azure Container Instances i zarządzania nimi, udzielając dostępu do grupy zasobów:

az role assignment create \
  --assignee $(az acr task show \
  --name hello-world \
  --registry $REGISTRY \
  --query identity.principalId --output tsv) \
  --scope $(az group show -n $ACI_RG --query id -o tsv) \
  --role owner

Po utworzeniu i skonfigurowaniu zadania uruchom zadanie, aby skompilować i wdrożyć hello-world obraz:

az acr task run -r $REGISTRY -n hello-world

Po utworzeniu pobierz adres IP kontenera hostowania hello-world obrazu.

az container show \
  --resource-group $ACI_RG \
  --name ${ACI} \
  --query ipAddress.ip \
  --out tsv

W przeglądarce przejdź do adresu IP, aby wyświetlić uruchomioną aplikację.

Aktualizowanie obrazu podstawowego przy użyciu "wątpliwej" zmiany

Ta sekcja symuluje zmianę obrazu podstawowego, która może powodować problemy w środowisku.

Otwórz Dockerfile w rozwidlonym base-image-node repozytorium.
Zmień wartość na BACKGROUND_COLOR , Orange aby zasymulować zmianę.

ARG REGISTRY_NAME=
FROM ${REGISTRY_NAME}node:15-alpine
ENV NODE_VERSION 15-alpine
ENV BACKGROUND_COLOR Orange

Zatwierdź zmianę i obejrzyj, aby usługa ACR Tasks automatycznie rozpoczynała tworzenie.

Obejrzyj zadanie, aby rozpocząć wykonywanie:

watch -n1 az acr task list-runs -r $REGISTRY_PUBLIC -o table

W końcu powinien zostać wyświetlony stan Succeeded na podstawie wyzwalacza :Commit

RUN ID    TASK      PLATFORM    STATUS     TRIGGER    STARTED               DURATION
--------  --------  ----------  ---------  ---------  --------------------  ----------
ca4       hub-node  linux       Succeeded  Commit     2020-10-24T05:02:29Z  00:00:22

Wpisz Ctrl+C , aby zamknąć polecenie zegarka, a następnie wyświetlić dzienniki najnowszego przebiegu:

az acr task logs -r $REGISTRY_PUBLIC

node Gdy obraz zostanie ukończony, watch aby usługa ACR Tasks automatycznie zaczęła kompilować hello-world obraz:

watch -n1 az acr task list-runs -r $REGISTRY -o table

W końcu powinien zostać wyświetlony stan Succeeded na podstawie wyzwalacza :Image Update

RUN ID    TASK         PLATFORM    STATUS     TRIGGER       STARTED               DURATION
--------  -----------  ----------  ---------  ------------  --------------------  ----------
dau       hello-world  linux       Succeeded  Image Update  2020-10-24T05:08:45Z  00:00:31

Wpisz Ctrl+C , aby zamknąć polecenie zegarka, a następnie wyświetlić dzienniki najnowszego przebiegu:

az acr task logs -r $REGISTRY

Po zakończeniu pobierz adres IP witryny hostująca zaktualizowany hello-world obraz:

az container show \
  --resource-group $ACI_RG \
  --name ${ACI} \
  --query ipAddress.ip \
  --out tsv

W przeglądarce przejdź do witryny, która powinna mieć pomarańczowe (wątpliwe) tło.

Zaewidencjonowanie

W tym momencie utworzono hello-world obraz, który jest automatycznie oparty na zatwierdzeniach usługi Git i zmianach w obrazie podstawowym node . W tym przykładzie zadanie jest kompilowanie względem obrazu podstawowego w Azure Container Registry, ale można użyć dowolnego obsługiwanego rejestru.

Aktualizacja obrazu podstawowego automatycznie ponownie uruchamia zadanie po zaktualizowaniu node obrazu. Jak widać tutaj, nie wszystkie aktualizacje są poszukiwane.

Importowane przez bramki zawartości publicznej

Aby zapobiec wystąpieniu zmian nadrzędnych w krytycznych obciążeniach, można dodać skanowanie zabezpieczeń i testy funkcjonalne.

W tej sekcji utworzysz zadanie usługi ACR w następujący sposób:

Tworzenie obrazu testowego
Uruchamianie skryptu testu funkcjonalnego względem obrazu testowego ./test.sh
Jeśli testy obrazu zostały pomyślnie wykonane, zaimportuj obraz publiczny do rejestru baseimages

Dodawanie testowania automatyzacji

Aby zawężyć dowolną zawartość nadrzędną, zaimplementowano zautomatyzowane testowanie. W tym przykładzie podano parametr , test.sh który sprawdza wartość $BACKGROUND_COLOR. Jeśli test zakończy się niepowodzeniem, zwracany jest element z EXIT_CODE1 , który powoduje niepowodzenie kroku zadania usługi ACR, kończąc uruchomienie zadania. Testy można rozszerzyć w dowolnej formie narzędzi, w tym wyników rejestrowania. Brama jest zarządzana przez odpowiedź z przekazywaniem/niepowodzeniem w skrycie, odtworzyną tutaj:

if [ ""$(echo $BACKGROUND_COLOR | tr '[:lower:]' '[:upper:]') = 'RED' ]; then
    echo -e "\e[31mERROR: Invalid Color:\e[0m" ${BACKGROUND_COLOR}
    EXIT_CODE=1
else
  echo -e "\e[32mValidation Complete - No Known Errors\e[0m"
fi
exit ${EXIT_CODE}

YaML zadania

Przejrzyj plik acr-task.yaml w import-baseimage-node repozytorium, który wykonuje następujące kroki:

Skompiluj obraz podstawowy testowy przy użyciu następującego pliku Dockerfile:

ARG REGISTRY_FROM_URL=
FROM ${REGISTRY_FROM_URL}node:15-alpine
WORKDIR /test
COPY ./test.sh .
CMD ./test.sh

Po zakończeniu zweryfikuj obraz, uruchamiając kontener, który jest uruchamiany ./test.sh
Tylko w przypadku pomyślnego ukończenia uruchom kroki importowania, które są obsługiwane za pomocą polecenia when: ['validate-base-image']

version: v1.1.0
steps:
  - id: build-test-base-image
    # Build off the base image we'll track
    # Add a test script to do unit test validations
    # Note: the test validation image isn't saved to the registry
    # but the task logs captures log validation results
    build: >
      --build-arg REGISTRY_FROM_URL={{.Values.REGISTRY_FROM_URL}}
      -f ./Dockerfile
      -t {{.Run.Registry}}/node-import:test
      .
  - id: validate-base-image
    # only continues if node-import:test returns a non-zero code
    when: ['build-test-base-image']
    cmd: "{{.Run.Registry}}/node-import:test"
  - id: pull-base-image
    # import the public image to base-artifacts
    # Override the stable tag,
    # and create a unique tag to enable rollback
    # to a previously working image
    when: ['validate-base-image']
    cmd: >
        docker pull {{.Values.REGISTRY_FROM_URL}}node:15-alpine
  - id: retag-base-image
    when: ['pull-base-image']
    cmd: docker tag {{.Values.REGISTRY_FROM_URL}}node:15-alpine {{.Run.Registry}}/node:15-alpine
  - id: retag-base-image-unique-tag
    when: ['pull-base-image']
    cmd: docker tag {{.Values.REGISTRY_FROM_URL}}node:15-alpine {{.Run.Registry}}/node:15-alpine-{{.Run.ID}}
  - id: push-base-image
    when: ['retag-base-image', 'retag-base-image-unique-tag']
    push:
    - "{{.Run.Registry}}/node:15-alpine"
    - "{{.Run.Registry}}/node:15-alpine-{{.Run.ID}}"

Tworzenie zadania do importowania i testowania obrazu podstawowego

  az acr task create \
  --name base-import-node \
  -f acr-task.yaml \
  -r $REGISTRY_BASE_ARTIFACTS \
  --context $GIT_NODE_IMPORT \
  --git-access-token $(az keyvault secret show \
                        --vault-name $AKV \
                        --name github-token \
                        --query value -o tsv) \
  --set REGISTRY_FROM_URL=${REGISTRY_PUBLIC_URL}/ \
  --assign-identity

Dodaj poświadczenia do zadania dla symulowanego rejestru publicznego:

az acr task credential add \
  -n base-import-node \
  -r $REGISTRY_BASE_ARTIFACTS \
  --login-server $REGISTRY_PUBLIC_URL \
  -u https://${AKV}.vault.azure.net/secrets/registry-${REGISTRY_PUBLIC}-user \
  -p https://${AKV}.vault.azure.net/secrets/registry-${REGISTRY_PUBLIC}-password \
  --use-identity [system]

Udziel zadania dostępu do odczytu wartości z magazynu kluczy:

az keyvault set-policy \
  --name $AKV \
  --resource-group $AKV_RG \
  --object-id $(az acr task show \
                  --name base-import-node \
                  --registry $REGISTRY_BASE_ARTIFACTS \
                  --query identity.principalId --output tsv) \
  --secret-permissions get

Uruchom zadanie importu:

az acr task run -n base-import-node -r $REGISTRY_BASE_ARTIFACTS

Uwaga

Jeśli zadanie zakończy się niepowodzeniem z powodu ./test.sh: Permission deniedpolecenia , upewnij się, że skrypt ma uprawnienia wykonywania i zatwierdź ponownie repozytorium Git:

chmod +x ./test.sh

Aktualizowanie `hello-world` obrazu w celu utworzenia z obrazu z bramy `node`

Utwórz token dostępu , aby uzyskać dostęp do rejestru base-artifacts z zakresu do read z node repozytorium. Następnie ustaw w magazynie kluczy:

az keyvault secret set \
  --vault-name $AKV \
  --name "registry-${REGISTRY_BASE_ARTIFACTS}-user" \
  --value "registry-${REGISTRY_BASE_ARTIFACTS}-user"

az keyvault secret set \
  --vault-name $AKV \
  --name "registry-${REGISTRY_BASE_ARTIFACTS}-password" \
  --value $(az acr token create \
              --name "registry-${REGISTRY_BASE_ARTIFACTS}-user" \
              --registry $REGISTRY_BASE_ARTIFACTS \
              --repository node content/read \
              -o tsv \
              --query credentials.passwords[0].value)

Dodaj poświadczenia do zadania hello-world dla rejestru artefaktów podstawowych:

az acr task credential add \
  -n hello-world \
  -r $REGISTRY \
  --login-server $REGISTRY_BASE_ARTIFACTS_URL \
  -u https://${AKV}.vault.azure.net/secrets/registry-${REGISTRY_BASE_ARTIFACTS}-user \
  -p https://${AKV}.vault.azure.net/secrets/registry-${REGISTRY_BASE_ARTIFACTS}-password \
  --use-identity [system]

Zaktualizuj zadanie, aby zmienić REGISTRY_FROM_URL element , aby użyć BASE_ARTIFACTS rejestru

az acr task update \
  -n hello-world \
  -r $REGISTRY \
  --set KEYVAULT=$AKV \
  --set REGISTRY_FROM_URL=${REGISTRY_BASE_ARTIFACTS_URL}/ \
  --set ACI=$ACI \
  --set ACI_RG=$ACI_RG

Uruchom zadanie hello-world , aby zmienić zależność obrazu podstawowego:

az acr task run -r $REGISTRY -n hello-world

Aktualizowanie obrazu podstawowego przy użyciu "prawidłowej" zmiany

Dockerfile Otwórz repozytorium inbase-image-node.
Zmień wartość na BACKGROUND_COLOR , Green aby zasymulować prawidłową zmianę.

ARG REGISTRY_NAME=
FROM ${REGISTRY_NAME}node:15-alpine
ENV NODE_VERSION 15-alpine
ENV BACKGROUND_COLOR Green

Zatwierdź zmianę i monitoruj sekwencję aktualizacji:

watch -n1 az acr task list-runs -r $REGISTRY_PUBLIC -o table

Po uruchomieniu wpisz Ctrl+C i monitoruj dzienniki:

az acr task logs -r $REGISTRY_PUBLIC

Po zakończeniu monitoruj zadanie importowania obrazu podstawowego :

watch -n1 az acr task list-runs -r $REGISTRY_BASE_ARTIFACTS -o table

Po uruchomieniu wpisz Ctrl+C i monitoruj dzienniki:

az acr task logs -r $REGISTRY_BASE_ARTIFACTS

Po zakończeniu monitoruj zadanie hello-world :

watch -n1 az acr task list-runs -r $REGISTRY -o table

Po uruchomieniu wpisz Ctrl+C i monitoruj dzienniki:

az acr task logs -r $REGISTRY

Po zakończeniu pobierz adres IP witryny hostująca zaktualizowany hello-world obraz:

az container show \
  --resource-group $ACI_RG \
  --name ${ACI} \
  --query ipAddress.ip \
  --out tsv

W przeglądarce przejdź do witryny, która powinna mieć zielone (prawidłowe) tło.

Wyświetlanie przepływu pracy z bramą

Wykonaj ponownie kroki opisane w poprzedniej sekcji z kolorem tła czerwonym.

Otwórz plik Dockerfile w base-image-node repozytorium
Zmień wartość na BACKGROUND_COLOR , Red aby zasymulować nieprawidłową zmianę.

ARG REGISTRY_NAME=
FROM ${REGISTRY_NAME}node:15-alpine
ENV NODE_VERSION 15-alpine
ENV BACKGROUND_COLOR Red

Zatwierdź zmianę i monitoruj sekwencję aktualizacji:

watch -n1 az acr task list-runs -r $REGISTRY_PUBLIC -o table

Po uruchomieniu wpisz Ctrl+C i monitoruj dzienniki:

az acr task logs -r $REGISTRY_PUBLIC

Po zakończeniu monitoruj zadanie importowania obrazu podstawowego :

watch -n1 az acr task list-runs -r $REGISTRY_BASE_ARTIFACTS -o table

Po uruchomieniu wpisz Ctrl+C i monitoruj dzienniki:

az acr task logs -r $REGISTRY_BASE_ARTIFACTS

W tym momencie powinna zostać wyświetlona walidacja zadania base-import-node i zatrzymanie sekwencji w celu opublikowania hello-world aktualizacji. Dane wyjściowe są podobne do następujących:

[...]
2020/10/30 03:57:39 Launching container with name: validate-base-image
Validating Image
NODE_VERSION: 15-alpine
BACKGROUND_COLOR: Red
ERROR: Invalid Color: Red
2020/10/30 03:57:40 Container failed during run: validate-base-image. No retries remaining.
failed to run step ID: validate-base-image: exit status 1

Publikowanie aktualizacji w usłudze `hello-world`

Zmiany obrazu hello-world będą nadal korzystać z ostatniego zweryfikowanych obrazów node .

Wszelkie dodatkowe zmiany obrazu podstawowego, które przechodzą weryfikacje bramek, spowodują wyzwolenie aktualizacji obrazu podstawowego node do hello-world obrazu.

Czyszczenie

Gdy zasoby używane w tym artykule nie będą już potrzebne, usuń je.

az group delete -n $REGISTRY_RG --no-wait -y
az group delete -n $REGISTRY_PUBLIC_RG --no-wait -y
az group delete -n $REGISTRY_BASE_ARTIFACTS_RG --no-wait -y
az group delete -n $AKV_RG --no-wait -y
az group delete -n $ACI_RG --no-wait -y

Następne kroki

W tym artykule. Użyto zadań usługi ACR do utworzenia zautomatyzowanego przepływu pracy gating w celu wprowadzenia zaktualizowanych obrazów bazowych do środowiska. Zobacz powiązane informacje dotyczące zarządzania obrazami w Azure Container Registry.

Udostępnij za pośrednictwem

Jak korzystać z publicznej zawartości i utrzymywać je za pomocą zadań Azure Container Registry

Omówienie scenariusza

Wymagania wstępne

Ustawianie zmiennych środowiskowych

Repozytoria Git i tokeny

poświadczenia Docker Hub

Tworzenie rejestrów

Tworzenie magazynu kluczy i ustawianie wpisów tajnych

Tworzenie grupy zasobów dla wystąpienia kontenera platformy Azure

Tworzenie publicznego obrazu podstawowego `node`

`hello-world` Tworzenie obrazu

Tworzenie tokenu na potrzeby dostępu ściągnięcia do symulowanego rejestru publicznego

Tworzenie tokenu na potrzeby dostępu ściągnięcia przez Azure Container Instances

Tworzenie zadania do kompilowania i obsługi `hello-world` obrazu

Aktualizowanie obrazu podstawowego przy użyciu "wątpliwej" zmiany

Zaewidencjonowanie

Importowane przez bramki zawartości publicznej

Dodawanie testowania automatyzacji

YaML zadania

Tworzenie zadania do importowania i testowania obrazu podstawowego

Aktualizowanie `hello-world` obrazu w celu utworzenia z obrazu z bramy `node`

Aktualizowanie obrazu podstawowego przy użyciu "prawidłowej" zmiany

Wyświetlanie przepływu pracy z bramą

Publikowanie aktualizacji w usłudze `hello-world`

Czyszczenie

Następne kroki

Dodatkowe zasoby

Udostępnij za pośrednictwem

Jak korzystać z publicznej zawartości i utrzymywać je za pomocą zadań Azure Container Registry

Omówienie scenariusza

Wymagania wstępne

Ustawianie zmiennych środowiskowych

Repozytoria Git i tokeny

poświadczenia Docker Hub

Tworzenie rejestrów

Tworzenie magazynu kluczy i ustawianie wpisów tajnych

Tworzenie grupy zasobów dla wystąpienia kontenera platformy Azure

Tworzenie publicznego obrazu podstawowego node

hello-world Tworzenie obrazu

Tworzenie tokenu na potrzeby dostępu ściągnięcia do symulowanego rejestru publicznego

Tworzenie tokenu na potrzeby dostępu ściągnięcia przez Azure Container Instances

Tworzenie zadania do kompilowania i obsługi hello-world obrazu

Aktualizowanie obrazu podstawowego przy użyciu "wątpliwej" zmiany

Zaewidencjonowanie

Importowane przez bramki zawartości publicznej

Dodawanie testowania automatyzacji

YaML zadania

Tworzenie zadania do importowania i testowania obrazu podstawowego

Aktualizowanie hello-world obrazu w celu utworzenia z obrazu z bramy node

Aktualizowanie obrazu podstawowego przy użyciu "prawidłowej" zmiany

Wyświetlanie przepływu pracy z bramą

Publikowanie aktualizacji w usłudze hello-world

Czyszczenie

Następne kroki

Dodatkowe zasoby

Tworzenie publicznego obrazu podstawowego `node`

`hello-world` Tworzenie obrazu

Tworzenie zadania do kompilowania i obsługi `hello-world` obrazu

Aktualizowanie `hello-world` obrazu w celu utworzenia z obrazu z bramy `node`

Publikowanie aktualizacji w usłudze `hello-world`