Obrazy z wieloma architekturami w rejestrze kontenerów platformy Azure

Artykuł
10/31/2023

W tym artykule przedstawiono obrazy z wieloma architekturami (multi-arch) oraz sposób używania funkcji Azure Container Registry w celu ułatwienia tworzenia, przechowywania i używania ich.

Obraz wielo arch jest typem obrazu kontenera, który może łączyć warianty dla różnych architektur, a czasami w różnych systemach operacyjnych. W przypadku uruchamiania obrazu z obsługą wielu architektur klienci kontenerów będą automatycznie wybierać wariant obrazu zgodny z systemem operacyjnym i architekturą.

Manifesty i listy manifestów

Obrazy z wieloma łukami są oparte na manifestach obrazów i listach manifestów.

Manifest

Każdy obraz kontenera jest reprezentowany przez manifest. Manifest to plik JSON, który jednoznacznie identyfikuje obraz, odwołując się do jego warstw i odpowiadających im rozmiarów.

Podstawowy manifest obrazu systemu Linux hello-world wygląda podobnie do następującego:

{
  "schemaVersion": 2,
  "mediaType": "application/vnd.docker.distribution.manifest.v2+json",
  "config": {
      "mediaType": "application/vnd.docker.container.image.v1+json",
      "size": 1510,
      "digest": "sha256:fbf289e99eb9bca977dae136fbe2a82b6b7d4c372474c9235adc1741675f587e"
    },
  "layers": [
      {
        "mediaType": "application/vnd.docker.image.rootfs.diff.tar.gzip",
        "size": 977,
        "digest": "sha256:2c930d010525941c1d56ec53b97bd057a67ae1865eebf042686d2a2d18271ced"
      }
    ]
}

Manifest można wyświetlić w Azure Container Registry przy użyciu Azure Portal lub narzędzi, takich jak polecenie az acr manifest list-metadata w interfejsie wiersza polecenia platformy Azure.

Lista manifestów

Lista manifestu dla obrazu z wieloma łukami (zazwyczaj nazywana indeksem obrazów dla obrazów OCI) to kolekcja (indeks) obrazów, która jest tworzona przez określenie co najmniej jednej nazwy obrazów. Zawiera szczegółowe informacje o poszczególnych obrazach, takich jak obsługiwany system operacyjny i architektura, rozmiar i skrót manifestu. Lista manifestów może być używana w taki sam sposób jak nazwa obrazu w poleceniach docker pull i docker run .

Interfejs docker wiersza polecenia zarządza manifestami i listami manifestów przy użyciu polecenia manifestu platformy Docker .

Uwaga

docker manifest Obecnie polecenia i podpolecenia są eksperymentalne. Zobacz dokumentację platformy Docker, aby uzyskać szczegółowe informacje na temat korzystania z poleceń eksperymentalnych.

Listę manifestów można wyświetlić za docker manifest inspect pomocą polecenia . Poniżej przedstawiono dane wyjściowe dla obrazu mcr.microsoft.com/mcr/hello-world:latestz wieloma arch, który ma trzy manifesty: dwa dla architektury systemu operacyjnego Linux i jeden dla architektury systemu Windows.

{
  "schemaVersion": 2,
  "mediaType": "application/vnd.docker.distribution.manifest.list.v2+json",
  "manifests": [
    {
      "mediaType": "application/vnd.docker.distribution.manifest.v2+json",
      "size": 524,
      "digest": "sha256:83c7f9c92844bbbb5d0a101b22f7c2a7949e40f8ea90c8b3bc396879d95e899a",
      "platform": {
        "architecture": "amd64",
        "os": "linux"
      }
    },
    {
      "mediaType": "application/vnd.docker.distribution.manifest.v2+json",
      "size": 525,
      "digest": "sha256:873612c5503f3f1674f315c67089dee577d8cc6afc18565e0b4183ae355fb343",
      "platform": {
        "architecture": "arm64",
        "os": "linux"
      }
    },
    {
      "mediaType": "application/vnd.docker.distribution.manifest.v2+json",
      "size": 1124,
      "digest": "sha256:b791ad98d505abb8c9618868fc43c74aa94d08f1d7afe37d19647c0030905cae",
      "platform": {
        "architecture": "amd64",
        "os": "windows",
        "os.version": "10.0.17763.1697"
      }
    }
  ]
}

Gdy lista manifestów z wieloma łukami jest przechowywana w Azure Container Registry, można również wyświetlić listę manifestów przy użyciu Azure Portal lub narzędzi, takich jak polecenie az acr manifest list-metadata.

Importowanie obrazu z wieloma łukami

Istniejący obraz z wieloma archami można zaimportować do rejestru kontenerów platformy Azure przy użyciu polecenia az acr import . Składnia importu obrazów jest taka sama jak w przypadku obrazu z jedną architekturą. Podobnie jak importowanie obrazu z jedną architekturą, importowanie obrazu z wieloma archami nie korzysta z poleceń platformy Docker.

Aby uzyskać szczegółowe informacje, zobacz Importowanie obrazów kontenerów do rejestru kontenerów.

Wypychanie obrazu z wieloma łukami

Jeśli masz utworzone przepływy pracy do tworzenia obrazów kontenerów dla różnych architektur, wykonaj następujące kroki, aby wypchnąć obraz z wieloma łukami do rejestru kontenerów platformy Azure.

Tagowanie i wypychanie każdego obrazu specyficznego dla architektury do rejestru kontenerów. W poniższym przykładzie przyjęto założenie dwóch architektur systemu Linux: arm64 i amd64.

docker tag myimage:arm64 \
  myregistry.azurecr.io/multi-arch-samples/myimage:arm64

docker push myregistry.azurecr.io/multi-arch-samples/myimage:arm64

docker tag myimage:amd64 \
  myregistry.azurecr.io/multi-arch-samples/myimage:amd64

docker push myregistry.azurecr.io/multi-arch-samples/myimage:amd64

Uruchom polecenie docker manifest create , aby utworzyć listę manifestów, aby połączyć powyższe obrazy w obraz z wieloma łukami.

docker manifest create myregistry.azurecr.io/multi-arch-samples/myimage:multi \
 myregistry.azurecr.io/multi-arch-samples/myimage:arm64 \
 myregistry.azurecr.io/multi-arch-samples/myimage:amd64

Wypchnij manifest do rejestru kontenerów przy użyciu polecenia docker manifest push:
```
docker manifest push myregistry.azurecr.io/multi-arch-samples/myimage:multi
```
docker manifest inspect Użyj polecenia , aby wyświetlić listę manifestów. Przykładowe dane wyjściowe polecenia są wyświetlane w poprzedniej sekcji.

Po wypchnięciu manifestu z wieloma łukami do rejestru należy pracować z obrazem z wieloma łukami w taki sam sposób, jak w przypadku obrazu z jedną architekturą. Możesz na przykład ściągnąć obraz przy użyciu polecenia docker pull, a następnie użyć polecenia az acr repository , aby wyświetlić tagi, manifesty i inne właściwości obrazu.

Kompilowanie i wypychanie obrazu z wieloma łukami

Korzystając z funkcji usługi ACR Tasks, można utworzyć i wypchnąć obraz z wieloma łukami do rejestru kontenerów platformy Azure. Na przykład zdefiniuj wieloetapowe zadanie w pliku YAML, które kompiluje obraz z wieloma archami systemu Linux.

W poniższym przykładzie założono, że masz oddzielne pliki Dockerfile dla dwóch architektur: arm64 i amd64. Tworzy i wypycha obrazy specyficzne dla architektury, a następnie tworzy i wypycha manifest z wieloma łukami zawierający latest tag :

version: v1.1.0

steps:
- build: -t {{.Run.Registry}}/multi-arch-samples/myimage:{{.Run.ID}}-amd64 -f dockerfile.arm64 . 
- build: -t {{.Run.Registry}}/multi-arch-samples/myyimage:{{.Run.ID}}-arm64 -f dockerfile.amd64 . 
- push: 
    - {{.Run.Registry}}/multi-arch-samples/myimage:{{.Run.ID}}-arm64
    - {{.Run.Registry}}/multi-arch-samples/myimage:{{.Run.ID}}-amd64
- cmd: >
    docker manifest create
    {{.Run.Registry}}/multi-arch-samples/myimage:latest
    {{.Run.Registry}}/multi-arch-samples/myimage:{{.Run.ID}}-arm64
    {{.Run.Registry}}/multi-arch-samples/myimage:{{.Run.ID}}-amd64
- cmd: docker manifest push --purge {{.Run.Registry}}/multi-arch-samples/myimage:latest
- cmd: docker manifest inspect {{.Run.Registry}}/multi-arch-samples/myimage:latest

Następne kroki

Tworzenie obrazów kontenerów dla różnych architektur za pomocą usługi Azure Pipelines .
Dowiedz się więcej o tworzeniu obrazów wieloplatformowych przy użyciu eksperymentalnej wtyczki docker buildx .

Share via