libreria client Registro Azure Container per Python - versione 1.2.0

Registro Azure Container consente di archiviare e gestire immagini e artefatti del contenitore in un registro privato per tutti i tipi di distribuzioni di contenitori.

Usare la libreria client per Registro Azure Container per:

• Elencare immagini o artefatti in un registro
• Ottenere metadati per immagini e artefatti, repository e tag
• Impostare le proprietà di lettura/scrittura/eliminazione per gli elementi del Registro di sistema
• Eliminare immagini e artefatti, repository e tag

Codice | sorgentePacchetto (Pypi) | Pacchetto (Conda) | Documentazione | di riferimento sulle APIDocumentazione | dell'API RESTDocumentazione del prodotto

Dichiarazione di non responsabilità

Il supporto dei pacchetti Python di Azure SDK per Python 2.7 è terminato il 01 gennaio 2022. Per altre informazioni e domande, vedere https://github.com/Azure/azure-sdk-for-python/issues/20691Python 3.7 o versione successiva per usare questo pacchetto. Per altre informazioni, vedere Criteri di supporto per la versione di Azure SDK per Python.

Introduzione

Installare il pacchetto

Installare la libreria client Registro Azure Container per Python con pip:

pip install --pre azure-containerregistry

Prerequisiti

• Python 3.7 o versione successiva è necessario per usare questo pacchetto.
• Per usare questo pacchetto sono necessari una sottoscrizione di Azure e un account del Registro Azure Container .

Per creare un nuovo Registro Contenitori, è possibile usare il portale di Azure, Azure PowerShell o l'interfaccia della riga di comando di Azure. Di seguito è riportato un esempio basato sull'uso dell'interfaccia della riga di comando di Azure:

az acr create --name MyContainerRegistry --resource-group MyResourceGroup --location westus --sku Basic

Autenticare il client

La libreria di identità di Azure offre un semplice supporto di Azure Active Directory per l'autenticazione. DefaultAzureCredential Si presuppone che siano impostate le AZURE_CLIENT_IDvariabili di ambiente , AZURE_TENANT_IDe AZURE_CLIENT_SECRET . Per altre informazioni, vedere la sezione Variabili di ambiente di Azure Identity

# Create a ContainerRegistryClient that will authenticate through Active Directory
from azure.containerregistry import ContainerRegistryClient
from azure.identity import DefaultAzureCredential

endpoint = "https://mycontainerregistry.azurecr.io"
audience = "https://management.azure.com"
client = ContainerRegistryClient(endpoint, DefaultAzureCredential(), audience=audience)

Concetti chiave

Un registro archivia le immagini Docker e gli artefatti OCI. Un'immagine o un artefatto è costituito da un manifesto e livelli. Il manifesto di un'immagine descrive i livelli che costituiscono l'immagine ed è identificato in modo univoco dal digest. Un'immagine può anche essere "contrassegnata" per assegnargli un alias leggibile. A un'immagine o a un artefatto possono essere associati zero o più tag e ogni tag identifica in modo univoco l'immagine. Una raccolta di immagini che condividono lo stesso nome ma hanno tag diversi, viene definita repository.

Per altre informazioni, vedere Concetti relativi al Registro Container.

Esempio

Le sezioni seguenti forniscono diversi frammenti di codice relativi ad alcune delle attività più comuni del servizio Registro Azure Container, tra cui:

• Operazioni del Registro di sistema:
  • Elencare repository
  • Elencare i tag con accesso anonimo
  • Impostare le proprietà degli artefatti
  • Eliminare le immagini
• Operazioni blob e manifesto:
  • Caricare immagini
  • Scaricare immagini
  • Elimina manifesto
  • Eliminare un BLOB

Si noti che ogni esempio presuppone che sia presente una CONTAINERREGISTRY_ENDPOINT variabile di ambiente impostata su una stringa contenente il https:// prefisso e il nome del server di accesso, ad esempio "https://myregistry.azurecr.io". Gli esempi di accesso anonimo ottengono il valore dell'endpoint dalla variabileCONTAINERREGISTRY_ANONREGISTRY_ENDPOINT di ambiente.

Elencare repository

Scorrere la raccolta di repository nel Registro di sistema.

with ContainerRegistryClient(self.endpoint, self.credential) as client:
    # Iterate through all the repositories
    for repository_name in client.list_repository_names():
        print(repository_name)

Elencare i tag con accesso anonimo

Scorrere la raccolta di tag nel repository con accesso anonimo.

with ContainerRegistryClient(endpoint) as anon_client:
    manifest = anon_client.get_manifest_properties("library/hello-world", "latest")
    print(f"Tags of {manifest.repository_name}: ")
    # Iterate through all the tags
    for tag in manifest.tags:
        print(tag)

Impostare le proprietà degli artefatti

Impostare le proprietà di un artefatto.

with ContainerRegistryClient(self.endpoint, self.credential) as client:
    # Set permissions on image "library/hello-world:v1"
    client.update_manifest_properties(
        "library/hello-world",
        "v1",
        can_write=False,
        can_delete=False
    )

Eliminare le immagini

Eliminare immagini precedenti alle prime tre nel repository.

with ContainerRegistryClient(self.endpoint, self.credential) as client:
    for repository in client.list_repository_names():
        # Keep the three most recent images, delete everything else
        manifest_count = 0
        for manifest in client.list_manifest_properties(
            repository, order_by=ArtifactManifestOrder.LAST_UPDATED_ON_DESCENDING
        ):
            manifest_count += 1
            if manifest_count > 3:
                # Make sure will have the permission to delete the manifest later
                client.update_manifest_properties(
                    repository,
                    manifest.digest,
                    can_write=True,
                    can_delete=True
                )
                print(f"Deleting {repository}:{manifest.digest}")
                client.delete_manifest(repository, manifest.digest)

Caricare immagini

Per caricare un'immagine completa, è necessario caricare singoli livelli e configurazione. Successivamente, è possibile caricare un manifesto che descrive un'immagine o un artefatto e assegnarlo un tag.

self.repository_name = "sample-oci-image"
layer = BytesIO(b"Sample layer")
config = BytesIO(json.dumps(
    {
        "sample config": "content",
    }).encode())
with ContainerRegistryClient(self.endpoint, self.credential) as client:
    # Upload a layer
    layer_digest, layer_size = client.upload_blob(self.repository_name, layer)
    print(f"Uploaded layer: digest - {layer_digest}, size - {layer_size}")
    # Upload a config
    config_digest, config_size = client.upload_blob(self.repository_name, config)
    print(f"Uploaded config: digest - {config_digest}, size - {config_size}")
    # Create an oci image with config and layer info
    oci_manifest = {
        "config": {
            "mediaType": "application/vnd.oci.image.config.v1+json",
            "digest": config_digest,
            "sizeInBytes": config_size,
        },
        "schemaVersion": 2,
        "layers": [
            {
                "mediaType": "application/vnd.oci.image.layer.v1.tar",
                "digest": layer_digest,
                "size": layer_size,
                "annotations": {
                    "org.opencontainers.image.ref.name": "artifact.txt",
                },
            },
        ],
    }
    # Set the image with tag "latest"
    manifest_digest = client.set_manifest(self.repository_name, oci_manifest, tag="latest")
    print(f"Uploaded manifest: digest - {manifest_digest}")

Scaricare immagini

Per scaricare un'immagine completa, è necessario scaricare il manifesto e quindi scaricare singoli livelli e configurazione.

with ContainerRegistryClient(self.endpoint, self.credential) as client:
    # Get the image
    get_manifest_result = client.get_manifest(self.repository_name, "latest")
    received_manifest = get_manifest_result.manifest
    print(f"Got manifest:\n{received_manifest}")
    
    # Download and write out the layers
    for layer in received_manifest["layers"]:
        # Remove the "sha256:" prefix from digest
        layer_file_name = layer["digest"].split(":")[1]
        try:
            stream = client.download_blob(self.repository_name, layer["digest"])
            with open(layer_file_name, "wb") as layer_file:
                for chunk in stream:
                    layer_file.write(chunk)
        except DigestValidationError:
            print(f"Downloaded layer digest value did not match. Deleting file {layer_file_name}.")
            os.remove(layer_file_name)
        print(f"Got layer: {layer_file_name}")
    # Download and write out the config
    config_file_name = "config.json"
    try:
        stream = client.download_blob(self.repository_name, received_manifest["config"]["digest"])
        with open(config_file_name, "wb") as config_file:
            for chunk in stream:
                config_file.write(chunk)
    except DigestValidationError:
        print(f"Downloaded config digest value did not match. Deleting file {config_file_name}.")
        os.remove(config_file_name)
    print(f"Got config: {config_file_name}")

Elimina manifesto

with ContainerRegistryClient(self.endpoint, self.credential) as client:
    get_manifest_result = client.get_manifest(self.repository_name, "latest")
    # Delete the image
    client.delete_manifest(self.repository_name, get_manifest_result.digest)

Eliminare un BLOB

with ContainerRegistryClient(self.endpoint, self.credential) as client:
    get_manifest_result = client.get_manifest(self.repository_name, "latest")
    received_manifest = get_manifest_result.manifest
    # Delete the layers
    for layer in received_manifest["layers"]:
        client.delete_blob(self.repository_name, layer["digest"])
    # Delete the config
    client.delete_blob(self.repository_name, received_manifest["config"]["digest"])

Risoluzione dei problemi

Per informazioni sulla risoluzione dei problemi, vedere la guida alla risoluzione dei problemi.

Generale

La libreria client del Registro Azure Container genererà eccezioni definite in Azure Core.

Registrazione

Questa libreria usa la libreria di registrazione standard per la registrazione.

Le informazioni di base sulle sessioni HTTP (URL, intestazioni e così via) vengono registrate a INFO livello.

La registrazione a livello dettagliato DEBUG , inclusi i corpi di richiesta/risposta e le intestazioni non contrassegnate , può essere abilitata nel client o per operazione con l'argomento logging_enable parola chiave.

Vedere la documentazione completa sulla registrazione dell'SDK con esempi qui.

Configurazione facoltativa

Gli argomenti di parole chiave facoltativi possono essere passati al client e al livello di operazione. La documentazione di riferimento di azure-core descrive le configurazioni disponibili per tentativi, registrazione, protocolli di trasporto e altro ancora.

Passaggi successivi

• Per altre informazioni, vedere azure.containerregistry e gli esempi.
• Guardare un video dimostrativo o approfondito.
• Altre informazioni sul servizio Registro Azure Container.

Contributo

In questo progetto sono benvenuti i contributi e i suggerimenti. Per la maggior parte dei contenuti è necessario sottoscrivere un contratto di licenza di collaborazione (CLA, Contributor License Agreement) che stabilisce che l'utente ha il diritto di concedere, e di fatto concede a Microsoft i diritti d'uso del suo contributo. Per informazioni dettagliate, visitare cla.microsoft.com.

Questo progetto ha adottato il Codice di comportamento di Microsoft per l'open source. Per altre informazioni, vedere Code of Conduct FAQ (Domande frequenti sul Codice di comportamento Open Source di Microsoft) oppure contattare opencode@microsoft.com per eventuali altre domande o commenti.