biblioteca cliente de Azure Container Registry para Python: versión 1.2.0

Azure Container Registry permite almacenar y administrar imágenes y artefactos de contenedor en un registro privado para todos los tipos de implementaciones de contenedor.

Use la biblioteca cliente de Azure Container Registry para lo siguiente:

• Enumeración de imágenes o artefactos en un registro
• Obtención de metadatos para imágenes y artefactos, repositorios y etiquetas
• Establecimiento de propiedades de lectura, escritura y eliminación en elementos del registro
• Eliminación de imágenes y artefactos, repositorios y etiquetas

Código | fuentePaquete (Pypi) | Paquete (Conda) | Documentación | de referencia de APIDocumentación | de la API RESTDocumentación del producto

Declinación de responsabilidades

Los paquetes de Python del SDK de Azure admiten Python 2.7 finalizó el 01 de enero de 2022. Para más información y preguntas, consulte https://github.com/Azure/azure-sdk-for-python/issues/20691Python 3.7 o posterior para usar este paquete. Para obtener más información, consulte la directiva de compatibilidad de la versión del SDK de Azure para Python.

Introducción

Instalar el paquete

Instale la biblioteca de Azure Container Registry para Python con pip:

pip install --pre azure-containerregistry

Requisitos previos

• Se requiere Python 3.7 o posterior para usar este paquete.
• Necesita una suscripción de Azure y una cuenta de Container Registry para usar este paquete.

Para crear una instancia de Container Registry, puede usar Azure Portal, Azure PowerShell o la CLI de Azure. A continuación se facilita un ejemplo mediante el uso de la CLI de Azure:

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

Autenticar el cliente

La biblioteca de identidades de Azure proporciona compatibilidad sencilla con Azure Active Directory para la autenticación. Se DefaultAzureCredential da por supuesto que se establecen las AZURE_CLIENT_IDvariables de entorno , AZURE_TENANT_IDy AZURE_CLIENT_SECRET para obtener más información, consulte la sección Variables de entorno de Identidad de Azure.

# 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)

Conceptos clave

Un registro almacena imágenes de Docker y artefactos de OCI. Una imagen o artefacto se compone de un manifiesto y capas. El manifiesto de una imagen describe las capas que componen la imagen y se identifica de forma única por su resumen. Una imagen también se puede "etiquetar" para darle un alias legible. Una imagen o artefacto puede tener cero o más etiquetas asociadas, y cada etiqueta identifica de forma única la imagen. Una colección de imágenes que comparten el mismo nombre, pero que tienen etiquetas diferentes, se conoce como repositorio.

Para más información, consulte Conceptos de Container Registry.

Ejemplos

En las secciones siguientes se proporcionan varios fragmentos de código que abarcan algunas de las tareas más comunes del servicio ACR, entre las que se incluyen:

• Operaciones del Registro:
  • Lista de repositorios
  • Enumerar etiquetas con acceso anónimo
  • Establecimiento de propiedades de artefactos
  • Eliminación de imágenes
• Operaciones de blob y manifiesto:
  • Carga de imágenes
  • Descargar imágenes
  • Eliminar manifiesto
  • Eliminación de un blob

Tenga en cuenta que cada ejemplo supone que hay una CONTAINERREGISTRY_ENDPOINT variable de entorno establecida en una cadena que contiene el https:// prefijo y el nombre del servidor de inicio de sesión, por ejemplo"https://myregistry.azurecr.io". Los ejemplos de acceso anónimo obtienen el valor del punto de conexión de la variableCONTAINERREGISTRY_ANONREGISTRY_ENDPOINT de entorno.

Lista de repositorios

Recorra en iteración la colección de repositorios del registro.

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

Enumerar etiquetas con acceso anónimo

Recorra en iteración la colección de etiquetas del repositorio con acceso anónimo.

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)

Establecimiento de propiedades de artefactos

Establezca las propiedades de un artefacto.

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
    )

Eliminación de imágenes

Elimine imágenes anteriores a las tres primeras del repositorio.

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)

Carga de imágenes

Para cargar una imagen completa, es necesario cargar capas y configuraciones individuales. Después, podemos cargar un manifiesto que describa una imagen o artefacto y asígnele una etiqueta.

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}")

Descargar imágenes

Para descargar una imagen completa, es necesario descargar su manifiesto y, a continuación, descargar capas individuales y configuración.

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}")

Eliminar manifiesto

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)

Eliminación de 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"])

Solución de problemas

Para obtener información sobre la solución de problemas, consulte la guía de solución de problemas.

General

La biblioteca cliente de ACR generará excepciones definidas en Azure Core.

Registro

Esta biblioteca usa la biblioteca de registro estándar para el registro.

La información básica sobre las sesiones HTTP (direcciones URL, encabezados, etc.) se registra en INFO el nivel .

El registro de nivel detallado DEBUG , incluidos los cuerpos de solicitud/respuesta y los encabezados no aprobados , se puede habilitar en el cliente o por operación con el argumento de palabra logging_enable clave.

Consulte la documentación completa del registro del SDK con ejemplos aquí.

Configuración opcional

Los argumentos de palabra clave opcionales se pueden pasar en el nivel de cliente y por operación. En la documentación de referencia de azure-core se describen las configuraciones disponibles para los reintentos, el registro, los protocolos de transporte, etc.

Pasos siguientes

• Continúe con azure.containerregistry y nuestros ejemplos.
• Vea un vídeo detallado o demostración.
• Obtenga más información sobre el servicio Azure Container Registry.

Contribuciones

Este proyecto agradece las contribuciones y sugerencias. La mayoría de las contribuciones requieren que acepte un Contrato de licencia para el colaborador (CLA) que declara que tiene el derecho a concedernos y nos concede los derechos para usar su contribución. Para obtener más información, visite cla.microsoft.com.

Este proyecto ha adoptado el Código de conducta de Microsoft Open Source. Para más información, consulte las preguntas más frecuentes del código de conducta o póngase en contacto con opencode@microsoft.com si tiene cualquier otra pregunta o comentario.