Jak korzystać z publicznej zawartości i obsługiwać je za pomocą zadań usługi Azure Container Registry

Artykuł
10/24/2024

Ten artykuł zawiera przykładowy przepływ pracy w usłudze Azure Container Registry, który ułatwia zarządzanie używaniem i konserwem zawartości publicznej:

Importuj 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 na potrzeby użycia wewnętrznego.
Wyzwalaj aktualizacje obrazu podstawowego dla aplikacji zależnych od zawartości publicznej.
Użyj usługi Azure Container Registry Tasks , aby zautomatyzować ten przepływ pracy.

Przepływ pracy został 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 ich ograniczania za pomocą usługi Azure Container Registry, zobacz wpis w blogu OCI Use Public Content (Korzystanie z publicznej zawartości OCI) i Zarządzanie zawartością publiczną za pomocą usługi 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. Zalecany jest interfejs 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 usługa Docker Hub (publicregistry) do obsługi zmiany obrazu podstawowego
- Rejestr zespołu (contoso) do udostępniania 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 hello-world i wdrażanie 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 obrębie elementuacr-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 zasobów utworzonych i użytych w przewodniku.

Ustawianie zmiennych środowiskowych

Skonfiguruj zmienne unikatowe dla ś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 jednak umieścić te zmienne w pojedynczej grupie zasobów w razie potrzeby.

Przykłady w tym artykule są formatowane dla 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 i tokeny Git

Aby zasymulować środowisko, rozwidlenie każdego z poniższych repozytoriów Git do repozytoriów, którymi można zarządzać.

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

Element :main dołączony 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) dla usługi ACR Tasks. 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 usługi Docker Hub

Aby uniknąć ograniczania przepustowości i żądań tożsamości podczas ściągania obrazów z usługi Docker Hub, utwórz token usługi 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 warstwy Premium, z których każdy należy do własnej grupy 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

Tworzenie magazynu 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 usługi 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 obrazu bazy publicznej `node`

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

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 do zadania poświadczenia usługi Docker Hub. Za pomocą polecenia acr task credentials można przekazać poświadczenia platformy Docker do dowolnego rejestru, w tym do usługi 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 zadaniu 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 utwórz 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 do ściągania przez usługę Azure Container Instances

Utwórz token dostępu do rejestru hostowania obrazu w zakresie do ściągnięciahello-world. 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.yaml hello-world repozytorium. Kroki zadania kompilują hello-world obraz, a następnie wdrażają go w usłudze Azure Container Instances. Grupa zasobów dla usługi Azure Container Instances została utworzona w poprzedniej sekcji. az container create Wywołując w zadaniu tylko różnicę w elemecie , zadanie jest wdrażane w tym samym wystąpieniu image:tagw 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 zadaniu 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 zadaniu dostępu do tworzenia usługi 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 zmiany "wątpliwej"

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

Otwórz Dockerfile plik 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 obserwuj, jak usługa ACR Tasks automatycznie rozpoczyna kompilowanie.

Zwróć się do zadania, 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 elementu Commit:

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

Naciśnij Ctrl+C , aby zakończyć działanie polecenia watch, a następnie wyświetlić dzienniki dla ostatniego uruchomienia:

az acr task logs -r $REGISTRY_PUBLIC

Po zakończeniu node watch tworzenia obrazu za pomocą usługi ACR Tasks można automatycznie rozpocząć kompilowanie hello-world obrazu:

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

W końcu powinien zostać wyświetlony stan Succeeded na podstawie wyzwalacza elementu 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

Naciśnij Ctrl+C , aby zakończyć działanie polecenia watch, a następnie wyświetlić dzienniki dla ostatniego uruchomienia:

az acr task logs -r $REGISTRY

Po zakończeniu pobierz adres IP witryny obsługującej 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.

Ewidencjonowanie

Na tym etapie utworzono hello-world obraz, który jest automatycznie tworzony na podstawie zatwierdzeń usługi Git i zmian w obrazie podstawowym node . W tym przykładzie zadanie jest kompilowanie względem obrazu podstawowego w usłudze 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 zmianom nadrzędnym przed przerywaniem krytycznych obciążeń, można dodać testy skanowania zabezpieczeń i funkcjonalności.

W tej sekcji utworzysz zadanie usługi ACR w celu:

Tworzenie obrazu testowego
Uruchamianie funkcjonalnego skryptu ./test.sh testowego względem obrazu testowego
Jeśli obraz zostanie pomyślnie przetestowany, zaimportuj publiczny obraz do rejestru baseimages

Dodawanie testowania automatyzacji

Aby uzyskać bramę do dowolnej nadrzędnej zawartości, zaimplementowane jest automatyczne 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_CODE 1 , co powoduje niepowodzenie kroku zadania usługi ACR, kończąc uruchomienie zadania. Testy można rozszerzyć w dowolnej formie narzędzi, w tym w wynikach rejestrowania. Brama jest zarządzana przez odpowiedź pass/fail w skry 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 w acr-task.yaml 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
Uruchom kroki importowania tylko w przypadku pomyślnego ukończenia, 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 zadaniu 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ź je z powrotem do repozytorium Git:

chmod +x ./test.sh

Aktualizowanie obrazu w celu kompilacji `hello-world` z obrazu z bramą `node`

Utwórz token dostępu, aby uzyskać dostęp do rejestru base-artifacts w zakresie do read z node repozytorium. Następnie ustaw wartość 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 tak, BASE_ARTIFACTS aby używał 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 zmiany "prawidłowej"

Otwórz repozytorium Dockerfile w base-image-node repozytorium.
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 obsługującej 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 ogrodzonych przepływów pracy

Ponownie wykonaj kroki opisane w poprzedniej sekcji z kolorem tła czerwonego.

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 powinno zostać wyświetlone zadanie base-import-node zakończone niepowodzeniem i zatrzymanie sekwencji publikowania 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 node obrazów.

Wszelkie dodatkowe zmiany w obrazie podstawowym node , które przechodzą walidację bramkową, będą wyzwalać aktualizacje obrazu podstawowego hello-world do 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 usłudze Azure Container Registry.

Udostępnij za pośrednictwem

Jak korzystać z publicznej zawartości i obsługiwać je za pomocą zadań usługi Azure Container Registry

Omówienie scenariusza

Wymagania wstępne

Ustawianie zmiennych środowiskowych

Repozytoria i tokeny Git

Poświadczenia usługi Docker Hub

Tworzenie rejestrów

Tworzenie magazynu kluczy i ustawianie wpisów tajnych

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

Tworzenie obrazu bazy publicznej `node`

`hello-world` Tworzenie obrazu

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

Tworzenie tokenu na potrzeby dostępu do ściągania przez usługę Azure Container Instances

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

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

Ewidencjonowanie

Importowane przez bramki zawartości publicznej

Dodawanie testowania automatyzacji

YaML zadania

Tworzenie zadania do importowania i testowania obrazu podstawowego

Aktualizowanie obrazu w celu kompilacji `hello-world` z obrazu z bramą `node`

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

Wyświetlanie ogrodzonych przepływów pracy

Publikowanie aktualizacji w usłudze `hello-world`

Czyszczenie

Następne kroki

Opinia

Dodatkowe zasoby

Udostępnij za pośrednictwem

Jak korzystać z publicznej zawartości i obsługiwać je za pomocą zadań usługi Azure Container Registry

Omówienie scenariusza

Wymagania wstępne

Ustawianie zmiennych środowiskowych

Repozytoria i tokeny Git

Poświadczenia usługi Docker Hub

Tworzenie rejestrów

Tworzenie magazynu kluczy i ustawianie wpisów tajnych

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

Tworzenie obrazu bazy publicznej node

hello-world Tworzenie obrazu

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

Tworzenie tokenu na potrzeby dostępu do ściągania przez usługę Azure Container Instances

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

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

Ewidencjonowanie

Importowane przez bramki zawartości publicznej

Dodawanie testowania automatyzacji

YaML zadania

Tworzenie zadania do importowania i testowania obrazu podstawowego

Aktualizowanie obrazu w celu kompilacji hello-world z obrazu z bramą node

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

Wyświetlanie ogrodzonych przepływów pracy

Publikowanie aktualizacji w usłudze hello-world

Czyszczenie

Następne kroki

Opinia

Dodatkowe zasoby

Tworzenie obrazu bazy publicznej `node`

`hello-world` Tworzenie obrazu

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

Aktualizowanie obrazu w celu kompilacji `hello-world` z obrazu z bramą `node`

Publikowanie aktualizacji w usłudze `hello-world`