Avbildningar med flera arkitekturer i azure-containerregistret

Artikel
10/16/2024

I den här artikeln beskrivs avbildningar 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 bild med flera valv (mer allmänt känt som ett bildindex för OCI-bilder) är en samling (index) av bilder, och du skapar en genom att ange ett eller flera bildnamn. Den innehåller information om var och en av bilderna, till exempel operativsystemet och arkitekturen som stöds, storlek och manifestsammandrag. Manifestlistan kan användas på samma sätt som ett bildnamn i docker pull och docker run kommandon.

docker CLI hanterar manifest och manifestlistor med kommandot docker-manifest.

Kommentar

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 hjälp av docker manifest inspect kommandot . 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 en 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 valv 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 kommandot az acr import . Syntaxen för bildimport är densamma som med en bild med en enda arkitektur. Precis som import av en avbildning med en enda 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 dessa steg 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 bilder till en bild 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 ett föregående avsnitt.

När du har push-överfört manifestet för flera valv till registret kan du arbeta med multi-arch-avbildningen på samma sätt som du gör med en avbildning med en enda arkitektur. Du kan till exempel hämta avbildningen med hjälp av docker pulloch använda az acr-lagringsplatskommandon för att visa taggar, manifest och andra egenskaper för avbildningen.

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

Med hjälp av funktionerna i ACR Tasks kan du skapa och skicka 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ätts att du har separata Dockerfiles för två arkitekturer, arm64 och amd64. Den skapar och push-överför de arkitekturspecifika avbildningarna, 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 multiplattformsbilder med hjälp av det experimentella Docker buildx-plugin-programmet .

Dela via