Condividi tramite

Immagini multiarchitettura nel Registro Azure Container

  • Articolo

Questo articolo presenta immagini multiarchitettura (multi-arch) e illustra come usare le funzionalità del Registro Azure Container per crearle, archiviarle e usarle.

Un'immagine multiarchitettura è un tipo di immagine del contenitore che può combinare varianti per architetture diverse e talvolta per sistemi operativi diversi. Quando si esegue un'immagine con supporto multiarchitettura, i client del contenitore selezioneranno automaticamente una variante dell'immagine corrispondente al sistema operativo e all'architettura.

Manifesti ed elenchi di manifesti

Le immagini multiarchitettura sono basate su manifesti di immagini ed elenchi di manifesti.

Manifesto

Ogni immagine del contenitore è rappresentata da un manifesto. Un manifesto è un file JSON che identifica in modo univoco l'immagine, facendo riferimento ai livelli e alle dimensioni corrispondenti.

Un manifesto di base per un'immagine hello-world Linux è simile al seguente:

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

È possibile visualizzare un manifesto in Registro Azure Container usando il portale di Azure o strumenti come il comando az acr manifest list-metadata nell'interfaccia della riga di comando di Azure.

Elenco di manifesti

Un elenco di manifesti per un'immagine multiarchitettura (nota più in genere come indice di immagini per le immagini OCI) è una raccolta (indice) di immagini che viene creata specificando uno o più nomi di immagine. Include informazioni dettagliate su ognuna delle immagini, ad esempio il sistema operativo e l'architettura supportati, le dimensioni e il digest del manifesto. L'elenco di manifesti può essere usato allo stesso modo di un nome immagine nei comandi docker pull e docker run.

L'interfaccia della riga di comando docker gestisce manifesti ed elenchi di manifesti usando il comando manifesto docker.

Nota

Attualmente, il comando docker manifest e i sottocomandi sono sperimentali. Per informazioni dettagliate sull'uso dei comandi sperimentali, vedere la documentazione di Docker.

È possibile visualizzare un elenco di manifesti usando il comando docker manifest inspect. Di seguito è riportato l'output per l'immagine multiarchitettura mcr.microsoft.com/mcr/hello-world:latest, con tre manifesti: due per le architetture del sistema operativo Linux e una per un'architettura di 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"
      }
    }
  ]
}

Quando un elenco di manifesti multiarchitettura viene archiviato in Registro Azure Container, è possibile visualizzare l'elenco dei manifesti anche tramite il portale di Azure o con strumenti come il comando az acr manifest list-metadata.

Importare un'immagine multiarchitettura

Un'immagine multiarchitettura esistente può essere importata in un registro contenitori di Azure usando il comando az acr import. La sintassi di importazione dell'immagine è identica a quella di un'immagine ad architettura singola. Analogamente all'importazione di un'immagine ad architettura singola, l'importazione di un'immagine multiarchitettura non usa comandi Docker.

Per i dettagli, vedere Importare immagini del contenitore in un registro contenitori.

Eseguire il push di un'immagine multiarchitettura

Quando si hanno flussi di lavoro di compilazione per creare immagini del contenitore per architetture diverse, seguire questa procedura per eseguire il push di un'immagine multiarchitettura nel Registro Azure Container.

  1. Contrassegnare ed eseguire il push di ogni immagine specifica dell'architettura nel registro contenitori. L'esempio seguente presuppone due architetture Linux: arm64 e 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

  2. Eseguire docker manifest create per creare un elenco di manifesti per combinare le immagini precedenti in un'immagine multiarchitettura.

    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

  3. Eseguire il push del manifesto nel registro contenitori usando docker manifest push:

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

  4. Usare il comando docker manifest inspect per visualizzare l'elenco dei manifesti. Un esempio di output dei comandi è illustrato in una sezione precedente.

Dopo aver eseguito il push del manifesto multiarchitettura nel registro di sistema, usare l'immagine multiarchitettura allo stesso modo di un'immagine ad architettura singola. Ad esempio, eseguire il pull dell'immagine usando docker pull e usare i comandi az acr repository per visualizzare tag, manifesti e altre proprietà dell'immagine.

Creare ed eseguire il push di un'immagine multiarchitettura

Usando le funzionalità di Attività del Registro Azure Container, è possibile compilare ed eseguire il push di un'immagine multiarchitettura nel Registro Azure Container. Ad esempio, definire un'attività in più passaggi in un file YAML che compila un'immagine multiarchitettura Linux.

L'esempio seguente presuppone che siano presenti Dockerfile separati per due architetture, arm64 e amd64. Compila ed esegue il push delle immagini specifiche dell'architettura, quindi crea ed esegue il push di un manifesto multiarchitettura con il tag 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

Passaggi successivi

  • Usare Azure Pipelines per compilare immagini del contenitore per architetture diverse.
  • Informazioni sulla creazione di immagini multipiattaforma con il plug-in sperimentale buildx di Docker.