biblioteka klienta Azure Container Registry dla języka Python — wersja 1.2.0

Azure Container Registry umożliwia przechowywanie obrazów kontenerów i artefaktów oraz zarządzanie nimi w prywatnym rejestrze dla wszystkich typów wdrożeń kontenerów.

Użyj biblioteki klienta, aby Azure Container Registry:

• Wyświetlanie listy obrazów lub artefaktów w rejestrze
• Uzyskiwanie metadanych dla obrazów i artefaktów, repozytoriów i tagów
• Ustawianie właściwości odczytu/zapisu/usuwania dla elementów rejestru
• Usuwanie obrazów i artefaktów, repozytoriów i tagów

Kod | źródłowyPakiet (Pypi) | Pakiet (Conda) | Dokumentacja referencyjna interfejsu | APIDokumentacja interfejsu | API RESTDokumentacja produktu

Zrzeczenie odpowiedzialności

Obsługa pakietów języka Python dla zestawu Azure SDK dla języka Python 2.7 zakończyła się 1 stycznia 2022 r. Aby uzyskać więcej informacji i pytań, zobacz https://github.com/Azure/azure-sdk-for-python/issues/20691Python 3.7 lub nowszy jest wymagany do korzystania z tego pakietu. Aby uzyskać więcej informacji, zapoznaj się z zasadami obsługi wersji zestawu Azure SDK dla języka Python.

Wprowadzenie

Instalowanie pakietu

Zainstaluj bibliotekę klienta Azure Container Registry dla języka Python za pomocą narzędzia pip:

pip install --pre azure-containerregistry

Wymagania wstępne

• Do korzystania z tego pakietu jest wymagany język Python w wersji 3.7 lub nowszej.
• Do korzystania z tego pakietu potrzebna jest subskrypcja platformy Azure i konto usługi Container Registry .

Aby utworzyć nowy rejestr kontenerów, możesz użyć witryny Azure Portal, Azure PowerShell lub interfejsu wiersza polecenia platformy Azure. Oto przykład użycia interfejsu wiersza polecenia platformy Azure:

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

Uwierzytelnianie klienta

Biblioteka tożsamości platformy Azure zapewnia łatwą obsługę usługi Azure Active Directory na potrzeby uwierzytelniania. Przyjęto DefaultAzureCredential założenie, że AZURE_CLIENT_IDustawiono zmienne środowiskowe , AZURE_TENANT_IDi AZURE_CLIENT_SECRET , aby uzyskać więcej informacji, zobacz sekcję Zmienne środowiskowe tożsamości platformy 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)

Kluczowe pojęcia

Rejestr przechowuje obrazy platformy Docker i artefakty OCI. Obraz lub artefakt składa się z manifestu i warstw. Manifest obrazu opisuje warstwy tworzące obraz i są jednoznacznie identyfikowane przez jego skrót. Obraz może być również "oznakowany", aby nadać mu alias czytelny dla człowieka. Z obrazem lub artefaktem może być skojarzonych zero lub więcej tagów , a każdy tag jednoznacznie identyfikuje obraz. Kolekcja obrazów, które mają taką samą nazwę, ale mają różne tagi, jest nazywana repozytorium.

Aby uzyskać więcej informacji, zobacz Container Registry Concepts (Pojęcia dotyczące usługi Container Registry).

Przykłady

Poniższe sekcje zawierają kilka fragmentów kodu obejmujących niektóre z najbardziej typowych zadań usługi ACR Service, w tym:

• Operacje rejestru:
  • Tworzenie listy repozytoriów
  • Wyświetlanie listy tagów z dostępem anonimowym
  • Ustawianie właściwości artefaktu
  • Usuwanie obrazów
• Operacje obiektów blob i manifestu:
  • Przekazywanie obrazów
  • Pobieranie obrazów
  • Usuwanie manifestu
  • Usuwanie obiektu blob

Należy pamiętać, że w każdym przykładzie założono, że istnieje CONTAINERREGISTRY_ENDPOINT zmienna środowiskowa ustawiona na ciąg zawierający https:// prefiks i nazwę serwera logowania, na przykład "https://myregistry.azurecr.io"". Przykłady dostępu anonimowego uzyskują wartość punktu końcowego ze zmiennej środowiskowejCONTAINERREGISTRY_ANONREGISTRY_ENDPOINT.

Tworzenie listy repozytoriów

Iteruj po kolekcji repozytoriów w rejestrze.

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

Wyświetlanie listy tagów z dostępem anonimowym

Iteracja po kolekcji tagów w repozytorium z dostępem anonimowym.

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)

Ustawianie właściwości artefaktu

Ustawianie właściwości artefaktu.

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
    )

Usuwanie obrazów

Usuń obrazy starsze niż pierwsze trzy w repozytorium.

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)

Przekazywanie obrazów

Aby przekazać pełny obraz, musimy przekazać poszczególne warstwy i konfigurację. Następnie możemy przekazać manifest opisujący obraz lub artefakt i przypisać mu 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}")

Pobieranie obrazów

Aby pobrać pełny obraz, musimy pobrać jego manifest, a następnie pobrać poszczególne warstwy i konfigurację.

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

Usuwanie manifestu

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)

Usuwanie obiektu 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"])

Rozwiązywanie problemów

Aby uzyskać informacje na temat rozwiązywania problemów, zapoznaj się z przewodnikiem rozwiązywania problemów.

Ogólne

Biblioteka klienta usługi ACR zgłosi wyjątki zdefiniowane w usłudze Azure Core.

Rejestrowanie

Ta biblioteka używa standardowej biblioteki rejestrowania do rejestrowania.

Podstawowe informacje o sesjach HTTP (adresach URL, nagłówkach itp.) są rejestrowane na INFO poziomie.

Szczegółowe DEBUG rejestrowanie na poziomie, w tym treści żądań/odpowiedzi i nieredagowanych nagłówków, można włączyć na kliencie lub na operację z argumentem słowa kluczowego logging_enable .

Zobacz pełną dokumentację rejestrowania zestawu SDK z przykładami tutaj.

Konfiguracja opcjonalna

Opcjonalne argumenty słów kluczowych można przekazać na poziomie klienta i na poziomie operacji. W dokumentacji referencyjnej platformy Azure opisano dostępne konfiguracje dotyczące ponownych prób, rejestrowania, protokołów transportowych i nie tylko.

Następne kroki

• Przejdź dalej za pomocą pliku azure.containerregistry i naszych przykładów.
• Obejrzyj film z pokazem lub głębokim nurkiem.
• Dowiedz się więcej o usłudze Azure Container Registry.

Współtworzenie

W tym projekcie zachęcamy do współtworzenia i zgłaszania sugestii. Współtworzenie w większości przypadków wymaga zgody na umowę licencyjną dotyczącą współautorów (CLA, Contributor License Agreement), zgodnie z którą współautor ma prawo udzielić i faktycznie udziela nam praw do używania wytworzonej przez siebie zawartości. Aby uzyskać szczegółowe informacje, odwiedź cla.microsoft.com.

W tym projekcie przyjęto Kodeks postępowania oprogramowania Open Source firmy Microsoft. Aby uzyskać więcej informacji, zobacz Często zadawane pytania dotyczące kodeksu postępowania lub skontaktuj się z opencode@microsoft.com dodatkowymi pytaniami lub komentarzami.