Avbildningar med flera arkitekturer i azure-containerregistret

Artikel
10/31/2023

Den här artikeln introducerar bilder med flera arkitekturer (flera valv) och hur du kan använda Azure Container Registry funktioner för att skapa, lagra och använda dem.

En avbildning med flera valv är en typ av containeravbildning som kan kombinera varianter för olika arkitekturer och ibland för olika operativsystem. När du kör en avbildning med stöd för flera arkitekturer väljer containerklienter automatiskt en avbildningsvariant som matchar ditt operativsystem och din arkitektur.

Manifest och manifestlistor

Bilder med flera valv baseras på bildmanifest och manifestlistor.

Manifest

Varje containeravbildning representeras av ett manifest. Ett manifest är en JSON-fil som unikt identifierar bilden och refererar till dess lager och deras motsvarande storlekar.

Ett grundläggande manifest för en Linux-avbildning hello-world ser ut ungefär så här:

{
  "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"
      }
    ]
}

Du kan visa ett manifest i Azure Container Registry med hjälp av Azure Portal eller verktyg som kommandot az acr manifest list-metadata i Azure CLI.

Manifestlista

En manifestlista för en flervalsbild (mer allmänt känd som ett avbildningsindex för OCI-bilder) är en samling (index) av bilder, och du skapar en genom att ange ett eller flera avbildningsnamn. Den innehåller information om var och en av avbildningarna, till exempel operativsystemet och arkitekturen som stöds, storlek och manifestsammandrag. Manifestlistan kan användas på samma sätt som ett avbildningsnamn i docker pull kommandona och docker run .

docker CLI hanterar manifest- och manifestlistor med kommandot dockermanifest.

Anteckning

docker manifest För närvarande är kommandot och underkommandona experimentella. Mer information om hur du använder experimentella kommandon finns i Docker-dokumentationen.

Du kan visa en manifestlista med kommandot docker manifest inspect . Följande är utdata för multi-arch-avbildningen mcr.microsoft.com/mcr/hello-world:latest, som har tre manifest: två för Linux OS-arkitekturer och ett för en Windows-arkitektur.

{
  "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"
      }
    }
  ]
}

När en manifestlista med flera bågar lagras i Azure Container Registry kan du också visa manifestlistan med hjälp av Azure Portal eller med verktyg som kommandot az acr manifest list-metadata.

Importera en bild med flera valv

En befintlig avbildning med flera valv kan importeras till ett Azure-containerregister med hjälp av kommandot az acr import . Syntaxen för avbildningsimport är samma som med en avbildning med en arkitektur. Precis som import av en avbildning med en arkitektur använder import av en avbildning med flera valv inte Docker-kommandon.

Mer information finns i Importera containeravbildningar till ett containerregister.

Push-överför en bild med flera valv

När du har skapat arbetsflöden för att skapa containeravbildningar för olika arkitekturer följer du de här stegen för att skicka en avbildning med flera valv till Ditt Azure-containerregister.

Tagga och push-överföra varje arkitekturspecifik avbildning till containerregistret. I följande exempel förutsätts två Linux-arkitekturer: arm64 och 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

Kör docker manifest create för att skapa en manifestlista för att kombinera föregående avbildningar till en avbildning med flera valv.

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

Push-överför manifestet till containerregistret med hjälp av docker manifest push:
```
docker manifest push myregistry.azurecr.io/multi-arch-samples/myimage:multi
```
docker manifest inspect Använd kommandot för att visa manifestlistan. Ett exempel på kommandoutdata visas i föregående avsnitt.

När du har push-överfört manifestet för flera bågar till registret kan du arbeta med avbildningen med flera valv på samma sätt som med en avbildning med en enda arkitektur. Hämta till exempel avbildningen med hjälp av docker pulloch använd az acr repository-kommandon för att visa taggar, manifest och andra egenskaper för avbildningen.

Skapa och push-överföra en avbildning med flera valv

Med hjälp av funktionerna i ACR Tasks kan du skapa och push-överföra en avbildning med flera valv till ditt Azure-containerregister. Definiera till exempel en uppgift i flera steg i en YAML-fil som skapar en Linux-avbildning med flera valv.

I följande exempel förutsätter vi att du har separata Dockerfiles för två arkitekturer, arm64 och amd64. Den skapar och push-överför de arkitekturspecifika avbildningarna och skapar och push-överför sedan ett manifest med flera valv som har taggen latest :

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

Nästa steg

Använd Azure Pipelines för att skapa containeravbildningar för olika arkitekturer.
Lär dig mer om att skapa avbildningar för flera plattformar med hjälp av det experimentella Docker buildx-plugin-programmet.

Share via