Share via

Biblioteka klienta poufnego rejestru platformy Azure dla języka Python — wersja 1.1.1

  • Artykuł

Rejestr poufny platformy Azure udostępnia usługę rejestrowania w niezmienialnym, odpornym na naruszenia rejestrze. W ramach portfolio poufnego przetwarzania na platformie Azure usługa Azure Confidential Ledger działa w bezpiecznych, opartych na sprzęcie zaufanych środowiskach wykonywania, nazywanych również enklawami. Jest ona oparta na platformie Microsoft Research Confidential Consortium Framework.

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

Wprowadzenie

Instalowanie pakietów

Zainstaluj usługę azure-confidentialledger i azure-identity za pomocą narzędzia pip:

pip install azure-identity azure-confidentialledger

Usługa azure-identity jest używana do uwierzytelniania usługi Azure Active Directory, jak pokazano poniżej.

Wymagania wstępne

  • Subskrypcja platformy Azure
  • Środowisko Python 3.6 lub nowsze
  • Uruchomione wystąpienie rejestru poufnego platformy Azure.
  • Zarejestrowany użytkownik w rejestrze poufnym, zwykle przypisany podczas tworzenia zasobów usługi ARM , z uprawnieniami Administrator .

Uwierzytelnianie klienta

Korzystanie z usługi Azure Active Directory

W tym dokumencie pokazano, jak używać wartości DefaultAzureCredential do uwierzytelniania w rejestrze poufnym za pośrednictwem usługi Azure Active Directory. ConfidentialLedgerClient Jednak akceptuje wszystkie poświadczenia azure-identity. Aby uzyskać więcej informacji na temat innych poświadczeń, zobacz dokumentację azure-identity .

Korzystanie z certyfikatu klienta

Zamiast usługi Azure Active Directory klienci mogą użyć certyfikatu klienta do uwierzytelniania za pośrednictwem wzajemnego protokołu TLS. azure.confidentialledger.ConfidentialLedgerCertificateCredential może być używany do tego celu.

Tworzenie klienta

DefaultAzureCredential program automatycznie obsłuży większość scenariuszy klienta zestawu Azure SDK. Aby rozpocząć, ustaw zmienne środowiskowe dla tożsamości usługi AAD zarejestrowanej w rejestrze poufnym.

export AZURE_CLIENT_ID="generated app id"
export AZURE_CLIENT_SECRET="random password"
export AZURE_TENANT_ID="tenant id"

DefaultAzureCredential Następnie będzie można uwierzytelnić element ConfidentialLedgerClient.

Konstruowanie klienta wymaga również adresu URL i identyfikatora rejestru poufnego, który można uzyskać z interfejsu wiersza polecenia platformy Azure lub witryny Azure Portal. Po pobraniu tych wartości zastąp wystąpienia elementów i "https://my-ledger-id.confidential-ledger.azure.com" w poniższych przykładach"my-ledger-id". Może być również konieczne zastąpienie "https://identity.confidential-ledger.core.azure.com" nazwą hosta z identityServiceUri opisu arm rejestru.

Ponieważ rejestry poufne używają certyfikatów z podpisem własnym, które są bezpiecznie generowane i przechowywane w enklawie, należy najpierw pobrać certyfikat podpisywania dla każdego rejestru poufnego z usługi tożsamości rejestru poufnego.

from azure.confidentialledger import ConfidentialLedgerClient
from azure.confidentialledger.certificate import ConfidentialLedgerCertificateClient
from azure.identity import DefaultAzureCredential

identity_client = ConfidentialLedgerCertificateClient()
network_identity = identity_client.get_ledger_identity(
    ledger_id="my-ledger-id"
)

ledger_tls_cert_file_name = "ledger_certificate.pem"
with open(ledger_tls_cert_file_name, "w") as cert_file:
    cert_file.write(network_identity["ledgerTlsCertificate"])

credential = DefaultAzureCredential()
ledger_client = ConfidentialLedgerClient(
    endpoint="https://my-ledger-id.confidential-ledger.azure.com",
    credential=credential,
    ledger_certificate_path=ledger_tls_cert_file_name
)

ConfidentialLedgerClient Wygodnie konstruktor pobierze certyfikat TLS rejestru (i zapisze go w określonym pliku), jeśli zostanie dostarczony z nieistniejącego pliku. Użytkownik jest odpowiedzialny za usunięcie utworzonego pliku zgodnie z potrzebami.

from azure.confidentialledger import ConfidentialLedgerClient
from azure.identity import DefaultAzureCredential

credential = DefaultAzureCredential()
ledger_client = ConfidentialLedgerClient(
    endpoint="https://my-ledger-id.confidential-ledger.azure.com",
    credential=credential,
    ledger_certificate_path="ledger_certificate.pem"
)

# The ledger TLS certificate is written to `ledger_certificate.pem`.

Aby wyjaśnić, że plik jest używany dla certyfikatu TLS rejestru, kolejne przykłady jawnie będą zapisywać certyfikat TLS rejestru do pliku.

Kluczowe pojęcia

Wpisy i transakcje rejestru

Każdy zapis w rejestrze poufnym platformy Azure generuje niezmienny wpis rejestru w usłudze. Zapisy, nazywane również transakcjami, są jednoznacznie identyfikowane przez identyfikatory transakcji, które zwiększają się wraz z każdym zapisem. Po zapisaniu wpisy rejestru mogą być pobierane w dowolnym momencie.

Kolekcje

Większość przypadków użycia obejmuje tylko jedną kolekcję na rejestr poufny, ale udostępniamy funkcję identyfikatora kolekcji w przypadku, gdy semantycznie lub logicznie różne grupy danych muszą być przechowywane w tym samym rejestrze poufnym.

Wpisy rejestru są pobierane przez element collectionId. Rejestr poufny zawsze zakłada stałą usługę określaną collectionId dla wpisów zapisanych bez określonego collectionId .

Użytkownicy

Użytkownicy są zarządzani bezpośrednio przy użyciu rejestru poufnego zamiast za pośrednictwem platformy Azure. Użytkownicy mogą być oparte na usłudze AAD, identyfikowane przez identyfikator obiektu usługi AAD lub oparte na certyfikatach, identyfikowane przez odcisk palca certyfikatu PEM.

Rachunki

Aby wymusić gwarancje integralności transakcji, rejestr poufny platformy Azure używa struktury danych [merkle][merkle_tree_wiki] do rejestrowania skrótu wszystkich bloków transakcji, które są dołączane do niezmiennego rejestru. Po zatwierdzeniu transakcji zapisu użytkownicy rejestru poufnego platformy Azure mogą uzyskać kryptograficzny dowód merkle lub potwierdzenie w wpisie utworzonym w rejestrze poufnym, aby sprawdzić, czy operacja zapisu została poprawnie zapisana. Potwierdzenie transakcji zapisu jest dowodem na to, że system zadeklarował odpowiednią transakcję i może służyć do sprawdzania, czy wpis został skutecznie dołączony do rejestru.

Zapoznaj się z następującym artykułem , aby uzyskać więcej informacji na temat potwierdzeń dotyczących zapisu transakcji rejestru poufnego platformy Azure.

Weryfikacja potwierdzenia

Po otrzymaniu potwierdzenia transakcji zapisu użytkownicy rejestru poufnego platformy Azure mogą zweryfikować zawartość pobranego potwierdzenia po algorytmie weryfikacji. Powodzenie weryfikacji jest dowodem na to, że operacja zapisu skojarzona z potwierdzeniem została poprawnie dołączona do niezmienialnego rejestru.

Aby uzyskać więcej informacji na temat procesu weryfikacji na potrzeby potwierdzeń transakcji zapisu poufnego rejestru platformy Azure, zapoznaj się z następującym artykułem .

Oświadczenia aplikacji

Aplikacje rejestru poufnego platformy Azure mogą dołączać dowolne dane nazywane oświadczeniami aplikacji do zapisywania transakcji. Te oświadczenia reprezentują akcje wykonywane podczas operacji zapisu. Po dołączeniu do transakcji skrót SHA-256 obiektu oświadczeń jest zawarty w rejestrze i zatwierdzony w ramach transakcji zapisu. Gwarantuje to, że skrót jest podpisany i nie można go modyfikować.

Później oświadczenia aplikacji można ujawnić w postaci nietrawnej w ładunku paragonu odpowiadającym tej samej transakcji, w której zostały dodane. Dzięki temu użytkownicy mogą wykorzystać informacje w paragonie, aby ponownie obliczyć to samo podsumowanie oświadczeń, które zostało dołączone i zalogowane przez wystąpienie poufnej księgi platformy Azure podczas transakcji. Skrót oświadczeń może być używany w ramach procesu weryfikacji potwierdzenia transakcji zapisu, zapewniając użytkownikom sposób w trybie offline, aby w pełni zweryfikować autentyczność zarejestrowanych oświadczeń.

Więcej szczegółów na temat formatu oświadczeń aplikacji i algorytmu obliczeń skrótów można znaleźć pod następującymi linkami:

Aby uzyskać więcej informacji na temat oświadczeń aplikacji CCF, zapoznaj się z następującymi stronami dokumentacji CCF:

Poufne przetwarzanie

Usługa Azure Confidential Computing umożliwia izolowanie i ochronę danych podczas ich przetwarzania w chmurze. Rejestr poufny platformy Azure działa na maszynach wirtualnych usługi Azure Confidential Computing, co zapewnia silniejszą ochronę danych przy użyciu szyfrowania danych.

Struktura poufnego konsorcjum

Rejestr poufny platformy Azure jest oparty na strukturze Poufne konsorcjum (CCF) firmy Microsoft Research. W ramach programu CCF aplikacje są zarządzane przez konsorcjum członków z możliwością przesyłania propozycji modyfikowania i zarządzania operacją aplikacji. W rejestrze poufnym platformy Azure platforma Microsoft Azure jest właścicielem tożsamości członka operatora, która umożliwia mu wykonywanie akcji ładu i konserwacji, takich jak zastępowanie węzłów w złej kondycji w rejestrze poufnym i uaktualnianie kodu enklawy.

Przykłady

Ta sekcja zawiera fragmenty kodu obejmujące typowe zadania, w tym:

Dołączanie wpisu

Dane, które muszą być przechowywane niezmiennie w sposób odporny na naruszenia, można zapisać w rejestrze poufnym platformy Azure, dołączając wpis do rejestru.

Ponieważ rejestr poufny jest systemem rozproszonym, rzadkie błędy przejściowe mogą spowodować utratę zapisów. W przypadku wpisów, które należy zachować, zaleca się sprawdzenie, czy zapis stał się trwały. W przypadku mniej ważnych zapisów, w których preferowana jest wyższa przepływność klienta, krok oczekiwania może zostać pominięty.

from azure.confidentialledger import ConfidentialLedgerClient
from azure.confidentialledger.certificate import ConfidentialLedgerCertificateClient
from azure.identity import DefaultAzureCredential

identity_client = ConfidentialLedgerCertificateClient()
network_identity = identity_client.get_ledger_identity(
    ledger_id="my-ledger-id"
)

ledger_tls_cert_file_name = "ledger_certificate.pem"
with open(ledger_tls_cert_file_name, "w") as cert_file:
    cert_file.write(network_identity["ledgerTlsCertificate"])

credential = DefaultAzureCredential()
ledger_client = ConfidentialLedgerClient(
    endpoint="https://my-ledger-id.confidential-ledger.azure.com",
    credential=credential,
    ledger_certificate_path=ledger_tls_cert_file_name
)

post_entry_result = ledger_client.create_ledger_entry(
        {"contents": "Hello world!"}
    )
transaction_id = post_entry_result["transactionId"]

wait_poller = ledger_client.begin_wait_for_commit(transaction_id)
wait_poller.wait()
print(f'Ledger entry at transaction id {transaction_id} has been committed successfully')

Alternatywnie klient może czekać na zatwierdzenie podczas pisania wpisu rejestru.

from azure.confidentialledger import ConfidentialLedgerClient
from azure.confidentialledger.certificate import ConfidentialLedgerCertificateClient
from azure.identity import DefaultAzureCredential

identity_client = ConfidentialLedgerCertificateClient()
network_identity = identity_client.get_ledger_identity(
    ledger_id="my-ledger-id"
)

ledger_tls_cert_file_name = "ledger_certificate.pem"
with open(ledger_tls_cert_file_name, "w") as cert_file:
    cert_file.write(network_identity["ledgerTlsCertificate"])

credential = DefaultAzureCredential()
ledger_client = ConfidentialLedgerClient(
    endpoint="https://my-ledger-id.confidential-ledger.azure.com",
    credential=credential,
    ledger_certificate_path=ledger_tls_cert_file_name
)

post_poller = ledger_client.begin_create_ledger_entry(
    {"contents": "Hello world again!"}
)
new_post_result = post_poller.result()
print(
    'The new ledger entry has been committed successfully at transaction id '
    f'{new_post_result["transactionId"]}'
)

Pobieranie wpisów rejestru

Pobieranie wpisów rejestru starszych niż najnowsze może zająć trochę czasu, ponieważ usługa ładuje wpisy historyczne, więc jest dostarczany wpis poller.

Wpisy rejestru są pobierane przez kolekcję. Zwracana wartość jest wartością zawartą w określonej kolekcji w punkcie w czasie identyfikowanym przez identyfikator transakcji.

from azure.confidentialledger import ConfidentialLedgerClient
from azure.confidentialledger.certificate import ConfidentialLedgerCertificateClient
from azure.identity import DefaultAzureCredential

identity_client = ConfidentialLedgerCertificateClient()
network_identity = identity_client.get_ledger_identity(
    ledger_id="my-ledger-id"
)

ledger_tls_cert_file_name = "ledger_certificate.pem"
with open(ledger_tls_cert_file_name, "w") as cert_file:
    cert_file.write(network_identity["ledgerTlsCertificate"])

credential = DefaultAzureCredential()
ledger_client = ConfidentialLedgerClient(
    endpoint="https://my-ledger-id.confidential-ledger.azure.com",
    credential=credential,
    ledger_certificate_path=ledger_tls_cert_file_name
)

post_poller = ledger_client.begin_create_ledger_entry(
    {"contents": "Original hello"}
)
post_result = post_poller.result()

post_transaction_id = post_result["transactionId"]

latest_entry = ledger_client.get_current_ledger_entry()
print(
    f'Current entry (transaction id = {latest_entry["transactionId"]}) '
    f'in collection {latest_entry["collectionId"]}: {latest_entry["contents"]}'
)

post_poller = ledger_client.begin_create_ledger_entry(
    {"contents": "Hello!"}
)
post_result = post_poller.result()

get_entry_poller = ledger_client.begin_get_ledger_entry(post_transaction_id)
older_entry = get_entry_poller.result()
print(
    f'Contents of {older_entry["entry"]["collectionId"]} at {post_transaction_id}: {older_entry["entry"]["contents"]}'
)

Tworzenie zapytania z zakresem

Wpisy rejestru mogą być pobierane z zakresu identyfikatorów transakcji. Wpisy będą zwracane tylko z domyślnej lub określonej kolekcji.

from azure.confidentialledger import ConfidentialLedgerClient
from azure.confidentialledger.certificate import ConfidentialLedgerCertificateClient
from azure.identity import DefaultAzureCredential

identity_client = ConfidentialLedgerCertificateClient()
network_identity = identity_client.get_ledger_identity(
    ledger_id="my-ledger-id"
)

ledger_tls_cert_file_name = "ledger_certificate.pem"
with open(ledger_tls_cert_file_name, "w") as cert_file:
    cert_file.write(network_identity["ledgerTlsCertificate"])

credential = DefaultAzureCredential()
ledger_client = ConfidentialLedgerClient(
    endpoint="https://my-ledger-id.confidential-ledger.azure.com",
    credential=credential,
    ledger_certificate_path=ledger_tls_cert_file_name
)

post_poller = ledger_client.begin_create_ledger_entry(
    {"contents": "First message"}
)
first_transaction_id = post_poller.result()["transactionId"]

for i in range(10):
    ledger_client.create_ledger_entry(
        {"contents": f"Message {i}"}
    )

post_poller = ledger_client.begin_create_ledger_entry(
    {"contents": "Last message"}
)
last_transaction_id = post_poller.result()["transactionId"]

ranged_result = ledger_client.list_ledger_entries(
    from_transaction_id=first_transaction_id,
    to_transaction_id=last_transaction_id,
)
for entry in ranged_result:
    print(f'Contents at {entry["transactionId"]}: {entry["contents"]}')

Zarządzanie użytkownikami

Użytkownicy z Administrator uprawnieniami mogą zarządzać użytkownikami rejestru poufnego bezpośrednio przy użyciu samego rejestru poufnego. Dostępne role to Reader (tylko do odczytu), Contributor (odczyt i zapis) oraz Administrator (odczyt, zapis i dodawanie lub usuwanie użytkowników).

from azure.confidentialledger import ConfidentialLedgerClient
from azure.confidentialledger.certificate import ConfidentialLedgerCertificateClient
from azure.identity import DefaultAzureCredential

identity_client = ConfidentialLedgerCertificateClient()
network_identity = identity_client.get_ledger_identity(
    ledger_id="my-ledger-id"
)

ledger_tls_cert_file_name = "ledger_certificate.pem"
with open(ledger_tls_cert_file_name, "w") as cert_file:
    cert_file.write(network_identity["ledgerTlsCertificate"])

credential = DefaultAzureCredential()
ledger_client = ConfidentialLedgerClient(
    endpoint="https://my-ledger-id.confidential-ledger.azure.com",
    credential=credential,
    ledger_certificate_path=ledger_tls_cert_file_name
)

user_id = "some AAD object id"
user = ledger_client.create_or_update_user(
    user_id, {"assignedRole": "Contributor"}
)
# A client may now be created and used with AAD credentials (i.e. AAD-issued JWT tokens) for the user identified by `user_id`.

user = ledger_client.get_user(user_id)
assert user["userId"] == user_id
assert user["assignedRole"] == "Contributor"

ledger_client.delete_user(user_id)

# For a certificate-based user, their user ID is the fingerprint for their PEM certificate.
user_id = "PEM certificate fingerprint"
user = ledger_client.create_or_update_user(
    user_id, {"assignedRole": "Reader"}
)

user = ledger_client.get_user(user_id)
assert user["userId"] == user_id
assert user["assignedRole"] == "Reader"

ledger_client.delete_user(user_id)

Korzystanie z uwierzytelniania certyfikatu

Klienci mogą uwierzytelniać się przy użyciu certyfikatu klienta w wzajemnym protokole TLS zamiast za pośrednictwem tokenu usługi Azure Active Directory. ConfidentialLedgerCertificateCredential dla takich klientów.

from azure.confidentialledger import (
    ConfidentialLedgerCertificateCredential,
    ConfidentialLedgerClient,
)
from azure.confidentialledger.certificate import ConfidentialLedgerCertificateClient

identity_client = ConfidentialLedgerCertificateClient()
network_identity = identity_client.get_ledger_identity(
    ledger_id="my-ledger-id"
)

ledger_tls_cert_file_name = "ledger_certificate.pem"
with open(ledger_tls_cert_file_name, "w") as cert_file:
    cert_file.write(network_identity["ledgerTlsCertificate"])

credential = ConfidentialLedgerCertificateCredential(
    certificate_path="Path to user certificate PEM file"
)
ledger_client = ConfidentialLedgerClient(
    endpoint="https://my-ledger-id.confidential-ledger.azure.com",
    credential=credential,
    ledger_certificate_path=ledger_tls_cert_file_name
)

Weryfikowanie potwierdzenia transakcji zapisu

Klienci mogą korzystać z biblioteki weryfikacji potwierdzenia w zestawie SDK, aby zweryfikować potwierdzenia transakcji zapisu wystawione przez wystąpienia poufne usługi Azure Legder. Narzędzie może służyć do pełnego weryfikowania paragonów w trybie offline, ponieważ algorytm weryfikacji nie wymaga połączenia z rejestrem poufnym ani żadną inną usługą platformy Azure.

Po dołączeniu nowego wpisu do rejestru (zapoznaj się z tym przykładem), można uzyskać potwierdzenie dla zatwierdzonej transakcji zapisu.

from azure.confidentialledger import ConfidentialLedgerClient
from azure.confidentialledger.certificate import ConfidentialLedgerCertificateClient
from azure.identity import DefaultAzureCredential

# Replace this with the Confidential Ledger ID 
ledger_id = "my-ledger-id"

# Setup authentication
credential = DefaultAzureCredential()

# Create a Ledger Certificate client and use it to
# retrieve the service identity for our ledger
identity_client = ConfidentialLedgerCertificateClient()
network_identity = identity_client.get_ledger_identity(
    ledger_id=ledger_id
)

# Save ledger service certificate into a file for later use
ledger_tls_cert_file_name = "ledger_certificate.pem"
with open(ledger_tls_cert_file_name, "w") as cert_file:
    cert_file.write(network_identity["ledgerTlsCertificate"])

# Create Confidential Ledger client
ledger_client = ConfidentialLedgerClient(
    endpoint=f"https://{ledger_id}.confidential-ledger.azure.com",
    credential=credential,
    ledger_certificate_path=ledger_tls_cert_file_name
)

# The method begin_get_receipt returns a poller that
# we can use to wait for the receipt to be available for retrieval 
get_receipt_poller = ledger_client.begin_get_receipt(transaction_id)
get_receipt_result = get_receipt_poller.result()

print(f"Write receipt for transaction id {transaction_id} was successfully retrieved: {get_receipt_result}")

Po pobraniu potwierdzenia dla transakcji zapisu można wywołać verify_receipt funkcję w celu sprawdzenia, czy potwierdzenie jest prawidłowe. Funkcja może zaakceptować opcjonalną listę oświadczeń aplikacji w celu zweryfikowania pod kątem skrótu oświadczeń potwierdzenia.

from azure.confidentialledger.receipt import (
    verify_receipt,
)

# Read contents of service certificate file saved in previous step.
with open(ledger_tls_cert_file_name, "r") as service_cert_file:
    service_cert_content = service_cert_file.read()

# Optionally read application claims, if any
application_claims = get_receipt_result.get("applicationClaims", None) 

try:
    # Verify the contents of the receipt.
    verify_receipt(get_receipt_result["receipt"], service_cert_content, application_claims=application_claims)
    print(f"Receipt for transaction id {transaction_id} successfully verified")
except ValueError:
    print(f"Receipt verification for transaction id {transaction_id} failed")

Pełny przykładowy program w języku Python pokazujący, jak dołączyć nowy wpis do uruchomionego wystąpienia poufnego rejestru, uzyskać potwierdzenie zatwierdzonej transakcji i sprawdzić, czy zawartość potwierdzenia można znaleźć w folderze samples : get_and_verify_receipt.py.

Interfejs API asynchroniczny

Ta biblioteka zawiera kompletny interfejs API asynchroniczny obsługiwany w języku Python 3.5 lub nowszym. Aby go użyć, należy najpierw zainstalować transport asynchroniczny, taki jak aiohttp. Aby uzyskać więcej informacji, zobacz dokumentację azure-core .

Klient asynchroniczny jest uzyskiwany z azure.confidentialledger.aioprogramu . Metody mają takie same nazwy i podpisy jak klient synchroniczny. Przykłady można znaleźć tutaj.

Rozwiązywanie problemów

Ogólne

Klienci rejestru poufnego zgłaszają wyjątki zdefiniowane w usłudze azure-core. Jeśli na przykład spróbujesz uzyskać transakcję, która nie istnieje, ConfidentialLedgerClient zgłasza błąd ResourceNotFoundError:

from azure.core.exceptions import ResourceNotFoundError
from azure.confidentialledger import ConfidentialLedgerClient
from azure.confidentialledger.certificate import ConfidentialLedgerCertificateClient
from azure.identity import DefaultAzureCredential

identity_client = ConfidentialLedgerCertificateClient()
network_identity = identity_client.get_ledger_identity(
    ledger_id="my-ledger-id"
)

ledger_tls_cert_file_name = "ledger_certificate.pem"
with open(ledger_tls_cert_file_name, "w") as cert_file:
    cert_file.write(network_identity["ledgerTlsCertificate"])

credential = DefaultAzureCredential()
ledger_client = ConfidentialLedgerClient(
    endpoint="https://my-ledger-id.confidential-ledger.azure.com",
    credential=credential,
    ledger_certificate_path=ledger_tls_cert_file_name
)

try:
    ledger_client.begin_get_ledger_entry(
        transaction_id="10000.100000"  # Using a very high id that probably doesn't exist in the ledger if it's relatively new.
    )
except ResourceNotFoundError as e:
    print(e.message)

Rejestrowanie

Ta biblioteka używa standardowej biblioteki rejestrowania do rejestrowania. Podstawowe informacje o sesjach HTTP (adresach URL, nagłówkach itp.) są rejestrowane na poziomie INFORMACJI.

Szczegółowe rejestrowanie na poziomie DEBUG, w tym treści żądań/odpowiedzi i nieredagowanych nagłówków, można włączyć na kliencie z argumentem logging_enable :

import logging
import sys

from azure.confidentialledger import ConfidentialLedgerClient
from azure.confidentialledger.certificate import ConfidentialLedgerCertificateClient
from azure.identity import DefaultAzureCredential

# Create a logger for the 'azure' SDK
logger = logging.getLogger('azure')
logger.setLevel(logging.DEBUG)

# Configure a console output
handler = logging.StreamHandler(stream=sys.stdout)
logger.addHandler(handler)

identity_client = ConfidentialLedgerCertificateClient()
network_identity = identity_client.get_ledger_identity(
    ledger_id="my-ledger-id"
)

ledger_tls_cert_file_name = "ledger_certificate.pem"
with open(ledger_tls_cert_file_name, "w") as cert_file:
    cert_file.write(network_identity["ledgerTlsCertificate"])

credential = DefaultAzureCredential()

# This client will log detailed information about its HTTP sessions, at DEBUG level.
ledger_client = ConfidentialLedgerClient(
    endpoint="https://my-ledger-id.confidential-ledger.azure.com",
    credential=credential,
    ledger_certificate_path=ledger_tls_cert_file_name,
    logging_enable=True,
)

Podobnie może logging_enable włączyć szczegółowe rejestrowanie dla pojedynczej operacji, nawet jeśli nie jest włączone dla klienta:

ledger_client.get_current_ledger_entry(logging_enable=True)

Następne kroki

Więcej przykładów kodu

Te przykłady kodu pokazują typowe operacje scenariuszy z biblioteką klienta Poufne rejestry platformy Azure.

Typowe scenariusze

Scenariusze zaawansowane

Dodatkowa dokumentacja

Aby uzyskać bardziej obszerną dokumentację dotyczącą poufnego rejestru platformy Azure, zobacz dokumentację referencyjną interfejsu API. Możesz również dowiedzieć się więcej na temat struktury poufnego konsorcjum Microsoft Research Firmy Microsoft.

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ź stronę https://cla.microsoft.com.

Po przesłaniu żądania ściągnięcia robot CLA automatycznie określi, czy musisz przekazać umowę CLA, i doda odpowiednie informacje do tego żądania (na przykład etykietę czy komentarz). Po prostu postępuj zgodnie z instrukcjami robota. Wystarczy zrobić to raz dla wszystkich repozytoriów, w przypadku których jest używana nasza umowa CLA.

W tym projekcie przyjęto Kodeks postępowania oprogramowania Open Source firmy Microsoft. Aby uzyskać więcej informacji, zobacz artykuł Code of Conduct FAQ (Często zadawane pytania dotyczące kodeksu postępowania). Jeśli będziesz mieć jeszcze jakieś pytania lub komentarze, wyślij wiadomość e-mail na adres opencode@microsoft.com.