Azure Confidential Ledger-Clientbibliothek für Python– Version 1.1.1

Artikel
08/11/2023

Azure Confidential Ledger bietet einen Dienst für die Protokollierung in einem unveränderlichen, manipulationssicheren Ledger. Als Teil des Azure Confidential Computing-Portfolios wird Azure Confidential Ledger in sicheren, hardwarebasierten vertrauenswürdigen Ausführungsumgebungen ausgeführt, die auch als Enclaves bezeichnet werden. Es basiert auf dem Confidential Consortium Framework von Microsoft Research.

Quellcode | Paket (PyPI) | Paket (Conda) | API-Referenzdokumentation | Produktdokumentation

Erste Schritte

Installieren von Paketen

Installieren Sie azure-confidentialledger und azure-identity mit pip:

pip install azure-identity azure-confidentialledger

azure-identity wird für die Azure Active Directory-Authentifizierung verwendet, wie unten gezeigt.

Voraussetzungen

Ein Azure-Abonnement
Python 3.6 oder höher
Eine ausgeführte Instanz von Azure Confidential Ledger
Ein registrierter Benutzer im Confidential Ledger, der in der Regel während der Arm-Ressourcenerstellung zugewiesen wird, mit Administrator Berechtigungen.

Authentifizieren des Clients

Verwenden von Azure Active Directory

Dieses Dokument veranschaulicht die Verwendung von DefaultAzureCredential zur Authentifizierung beim Confidential Ledger über Azure Active Directory. Akzeptiert jedoch ConfidentialLedgerClient alle Azure-Identity-Anmeldeinformationen . Weitere Informationen zu anderen Anmeldeinformationen finden Sie in der Dokumentation zu azure-identity .

Verwenden eines Clientzertifikats

Als Alternative zu Azure Active Directory können Clients ein Clientzertifikat verwenden, um sich über gegenseitiges TLS zu authentifizieren. azure.confidentialledger.ConfidentialLedgerCertificateCredential kann für diesen Zweck verwendet werden.

Erstellen eines Clients

DefaultAzureCredential behandelt automatisch die meisten Azure SDK-Clientszenarien. Legen Sie zunächst Umgebungsvariablen für die bei Ihrem Confidential Ledger registrierte AAD-Identität fest.

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

Kann dann DefaultAzureCredential den authentifizieren ConfidentialLedgerClient.

Die Erstellung des Clients erfordert auch die URL und ID Ihres Confidential Ledgers, die Sie über die Azure CLI oder das Azure-Portal abrufen können. Wenn Sie diese Werte abgerufen haben, ersetzen Sie instanzen von "my-ledger-id" und "https://my-ledger-id.confidential-ledger.azure.com" in den folgenden Beispielen. Möglicherweise müssen Sie auch durch den Hostnamen aus in identityServiceUri der ARM-Beschreibung Ihres Ledgers ersetzen"https://identity.confidential-ledger.core.azure.com".

Da Confidential Ledgers selbstsignierte Zertifikate verwenden, die sicher generiert und in einer Enclave gespeichert werden, muss das Signaturzertifikat für jeden Confidential Ledger zuerst vom Confidential Ledger Identity Service abgerufen werden.

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
)

Praktischerweise ruft der ConfidentialLedgerClient Konstruktor das Ledger-TLS-Zertifikat ab (und schreibt es in die angegebene Datei), wenn es mit einer nicht vorhandenen Datei bereitgestellt wird. Der Benutzer ist dafür verantwortlich, die erstellte Datei nach Bedarf zu entfernen.

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`.

Um klar zu machen, dass eine Datei für das Ledger-TLS-Zertifikat verwendet wird, schreiben nachfolgende Beispiele das Ledger-TLS-Zertifikat explizit in eine Datei.

Wichtige Begriffe

Ledgereinträge und Transaktionen

Jeder Schreibvorgang in Azure Confidential Ledger generiert einen unveränderlichen Ledgereintrag im Dienst. Schreibvorgänge, auch als Transaktionen bezeichnet, werden eindeutig durch Transaktions-IDs identifiziert, die mit jedem Schreibvorgang inkrementiert werden. Nach dem Schreiben können Ledgereinträge jederzeit abgerufen werden.

Sammlungen

Während die meisten Anwendungsfälle nur eine Sammlung pro Confidential Ledger umfassen, bieten wir die Sammlungs-ID-Funktion für den Fall, dass semantisch oder logisch unterschiedliche Gruppen von Daten in demselben Confidential Ledger gespeichert werden müssen.

Ledgereinträge werden von ihrer collectionIdabgerufen. Der Confidential Ledger geht immer von einer konstanten, vom Dienst festgelegten collectionId Konstante für Einträge aus, die ohne collectionId einen angegebenen geschrieben werden.

Benutzer

Benutzer werden direkt mit dem Confidential Ledger anstatt über Azure verwaltet. Benutzer können AAD-basiert sein, durch ihre AAD-Objekt-ID identifiziert oder zertifikatbasiert, identifiziert durch ihren PEM-Zertifikatfingerabdruck.

Receipts

Um Transaktionsintegritätsgarantien zu erzwingen, verwendet ein Azure Confidential Ledger eine [Merkle-Struktur][merkle_tree_wiki]-Datenstruktur, um den Hash aller Transaktionsblöcke aufzuzeichnen, die an den unveränderlichen Ledger angefügt werden. Nachdem ein Commit für eine Schreibtransaktion erfolgt ist, können Azure Confidential Ledger-Benutzer einen kryptografischen Merkle-Nachweis oder Beleg über den in einem Confidential Ledger erstellten Eintrag erhalten, um zu überprüfen, ob der Schreibvorgang ordnungsgemäß gespeichert wurde. Ein Beleg für eine Schreibtransaktion ist der Nachweis, dass das System ein Commit für die entsprechende Transaktion ausgeführt hat, und kann verwendet werden, um zu überprüfen, ob der Eintrag tatsächlich an den Ledger angefügt wurde.

Weitere Informationen zu Azure Confidential Ledger-Schreibtransaktionsbestätigungen finden Sie im folgenden Artikel .

Bestätigungsüberprüfung

Nachdem sie eine Bestätigung für eine Schreibtransaktion erhalten haben, können Azure Confidential Ledger-Benutzer den Inhalt des abgerufenen Belegs nach einem Überprüfungsalgorithmus überprüfen. Der Erfolg der Überprüfung ist ein Beweis dafür, dass der dem Beleg zugeordnete Schreibvorgang ordnungsgemäß an den unveränderlichen Ledger angefügt wurde.

Weitere Informationen zum Überprüfungsprozess für Azure Confidential Ledger-Schreibtransaktionen finden Sie im folgenden Artikel .

Anwendungsansprüche

Azure Confidential Ledger-Anwendungen können beliebige, als Anwendungsansprüche bezeichnete Daten anfügen, um Transaktionen zu schreiben. Diese Ansprüche stellen die Aktionen dar, die während eines Schreibvorgangs ausgeführt werden. Wenn er an eine Transaktion angefügt ist, wird der SHA-256-Digest des Anspruchsobjekts im Ledger aufgenommen und als Teil der Schreibtransaktion committet. Dadurch wird sichergestellt, dass der Digest angemeldet ist und nicht manipuliert werden kann.

Später können Anwendungsansprüche in ihrer nicht verdauten Form in der Empfangsnutzlast angezeigt werden, die derselben Transaktion entspricht, in der sie hinzugefügt wurden. Dadurch können Benutzer die Informationen im Beleg nutzen, um den gleichen Anspruchsdigest neu zu berechnen, der während der Transaktion vom Azure Confidential Ledger-instance angefügt und angemeldet wurde. Der Anspruchsdigest kann als Teil des Überprüfungsprozesses für den Schreibtransaktionsbeleg verwendet werden und bietet Benutzern eine Offline-Möglichkeit, die Echtheit der aufgezeichneten Ansprüche vollständig zu überprüfen.

Weitere Informationen zum Anwendungsanspruchsformat und zum Digestberechnungsalgorithmus finden Sie unter den folgenden Links:

Weitere Informationen zu CCF-Anwendungsansprüchen finden Sie auf den folgenden CCF-Dokumentationsseiten:

Confidential Computing

Mit Azure Confidential Computing können Sie Ihre Daten isolieren und schützen, während sie in der Cloud verarbeitet werden. Azure Confidential Ledger wird auf virtuellen Azure Confidential Computing-Computern ausgeführt und bietet somit einen besseren Datenschutz bei der Verschlüsselung der verwendeten Daten.

Confidential Consortium Framework

Azure Confidential Ledger basiert auf dem Open-Source Confidential Consortium Framework (CCF) von Microsoft Research. Unter CCF werden Anwendungen von einem Konsortium von Mitgliedern verwaltet, die Vorschläge zur Änderung und Steuerung des Anwendungsvorgangs einreichen können. In Azure Confidential Ledger besitzt Microsoft Azure eine Operatormitgliedsidentität, die es ermöglicht, Governance- und Wartungsaktionen auszuführen, z. B. das Ersetzen fehlerhafter Knoten im Confidential Ledger und das Aktualisieren des Enclave-Codes.

Beispiele

Dieser Abschnitt enthält Codeausschnitte zu allgemeinen Aufgaben, einschließlich:

Eintrag anfügen
Abrufen von Ledgereinträgen
Erstellen einer Bereichsabfrage
Verwalten von Benutzern
Verwenden der Zertifikatauthentifizierung
Überprüfen der Belege für Schreibtransaktionen

Eintrag anfügen

Daten, die unveränderlich auf manipulationssichere Weise gespeichert werden müssen, können in Azure Confidential Ledger gespeichert werden, indem ein Eintrag an den Ledger angefügt wird.

Da Confidential Ledger ein verteiltes System ist, können seltene vorübergehende Fehler dazu führen, dass Schreibvorgänge verloren gehen. Bei Einträgen, die beibehalten werden müssen, ist es ratsam, zu überprüfen, ob der Schreibvorgang dauerhaft wurde. Bei weniger wichtigen Schreibvorgängen, bei denen ein höherer Clientdurchsatz bevorzugt wird, kann der Warteschritt übersprungen werden.

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

Alternativ kann der Client beim Schreiben eines Ledgereintrags auf commit warten.

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

Abrufen von Ledgereinträgen

Das Abrufen von Ledgereinträgen, die älter als die neuesten sind, kann einige Zeit dauern, da der Dienst verlaufsbezogene Einträge lädt, sodass ein Poller bereitgestellt wird.

Ledgereinträge werden von der Auflistung abgerufen. Der zurückgegebene Wert ist der Wert, der zu dem Zeitpunkt in der angegebenen Auflistung enthalten ist, der durch die Transaktions-ID identifiziert wird.

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

Erstellen einer Bereichsabfrage

Ledgereinträge können über einen Bereich von Transaktions-IDs abgerufen werden. Einträge werden nur aus der Standardauflistung oder der angegebenen Auflistung zurückgegeben.

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

Verwalten von Benutzern

Benutzer mit Administrator Berechtigungen können Benutzer des Confidential Ledgers direkt mit dem Confidential Ledger selbst verwalten. Verfügbare Rollen sind Reader (schreibgeschützt), Contributor (Lesen und Schreiben) und Administrator (Lesen, Schreiben und Hinzufügen oder Entfernen von Benutzern).

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)

Verwenden der Zertifikatauthentifizierung

Clients können sich mit einem Clientzertifikat in gegenseitigem TLS authentifizieren, anstatt über ein Azure Active Directory-Token. ConfidentialLedgerCertificateCredential wird für solche Clients bereitgestellt.

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
)

Überprüfen der Belege für Schreibtransaktionen

Clients können die Belegüberprüfungsbibliothek im SDK nutzen, um von Azure Confidential Legder-Instanzen ausgestellte Schreibtransaktionsbestätigungen zu überprüfen. Das Hilfsprogramm kann verwendet werden, um Quittungen vollständig offline zu überprüfen, da der Überprüfungsalgorithmus nicht mit einem Vertraulichen Ledger oder einem anderen Azure-Dienst verbunden sein muss.

Sobald ein neuer Eintrag an den Ledger angefügt wurde (siehe dieses Beispiel), ist es möglich, eine Bestätigung für die committete Schreibtransaktion zu erhalten.

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

Nach dem Abrufen eines Belegs für eine Schreibtransaktion ist es möglich, die verify_receipt Funktion aufzurufen, um zu überprüfen, ob der Beleg gültig ist. Die Funktion kann eine optionale Liste von Anwendungsansprüchen akzeptieren, die anhand des Digests für Empfangsansprüche überprüft werden soll.

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

Ein vollständiges Python-Beispielprogramm, das zeigt, wie sie einen neuen Eintrag an eine ausgeführte Confidential Ledger-instance anfügen, eine Bestätigung für die committete Transaktion abrufen und überprüfen, ob der Beleginhalt unter dem Ordner samples zu finden ist: get_and_verify_receipt.py.

Asynchrone API

Diese Bibliothek enthält eine vollständige asynchrone API, die unter Python 3.5 und höher unterstützt wird. Um es verwenden zu können, müssen Sie zuerst einen asynchronen Transport installieren, z. B. aiohttp. Weitere Informationen finden Sie in der Dokumentation zu azure-core .

Ein asynchroner Client wird von azure.confidentialledger.aioabgerufen. Methoden haben dieselben Namen und Signaturen wie der synchrone Client. Beispiele finden Sie hier.

Problembehandlung

Allgemein

Confidential Ledger-Clients lösen ausnahmen aus, die in azure-core definiert sind. Wenn Sie beispielsweise versuchen, eine Transaktion abzurufen, die nicht vorhanden ist, ConfidentialLedgerClient löst ResourceNotFoundError aus:

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)

Protokollierung

Diese Bibliothek verwendet die Standardprotokollbibliothek für die Protokollierung. Grundlegende Informationen zu HTTP-Sitzungen (URLs, Header usw.) werden auf INFO-Ebene protokolliert.

Eine detaillierte Protokollierung auf DEBUG-Ebene, einschließlich Anforderungs-/Antworttexten und nicht ausgeführten Headern, kann auf einem Client mit dem logging_enable -Argument aktiviert werden:

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

Ebenso kann über logging_enable die ausführliche Protokollierung für einen einzelnen Vorgang aktiviert werden, auch wenn diese Funktion für den Client nicht aktiviert ist:

ledger_client.get_current_ledger_entry(logging_enable=True)

Nächste Schritte

Weiterer Beispielcode

Diese Codebeispiele zeigen allgemeine Szenariovorgänge mit der Azure Confidential Ledger-Clientbibliothek.

Häufige Szenarios

Schreiben in den Ledger:
- write_to_ledger.py
- write_to_ledger_async.py (asynchrone Version)
Schreiben Sie viele Ledgereinträge, und rufen Sie sie alle anschließend ab:
- list_ledger_entries.py
- list_ledger_entries_async.py (asynchrone Version)
Verwalten von Benutzern mithilfe der vom Dienst implementierten rollenbasierten Zugriffssteuerung:
- manage_users.py
- manage_users_async.py (asynchrone Version)

Erweiterte Szenarien

Verwenden von Sammlungen:
- use_collections.py
- use_collections_async.py (asynchrone Version)
Abrufen von Belegen für Ledgerschreibvorgänge:
- get_receipt.py
- get_receipt_async.py (asynchrone Version)
Überprüfen von Dienstdetails:
- verify_service.py
- verify_service_async.py (asynchrone Version)

Zusätzliche Dokumentation

Eine ausführlichere Dokumentation zu Azure Confidential Ledger finden Sie in der API-Referenzdokumentation. Sie können auch mehr über das Open-Source Confidential Consortium Framework von Microsoft Research erfahren.

Mitwirken

Beiträge und Vorschläge für dieses Projekt sind willkommen. Most contributions require you to agree to a Contributor License Agreement (CLA) declaring that you have the right to, and actually do, grant us the rights to use your contribution. Ausführliche Informationen finden Sie unter https://cla.microsoft.com.

Wenn Sie einen Pull Request (PR) übermitteln, überprüft ein CLA-Bot automatisch, ob Sie eine Lizenzvereinbarung bereitstellen und den PR entsprechend ergänzen müssen (z.B. mit einer Bezeichnung oder einem Kommentar). Führen Sie einfach die Anweisungen des Bots aus. Sie müssen dies nur einmal für alle Repositorys ausführen, die unsere CLA verwenden.

Für dieses Projekt gelten die Microsoft-Verhaltensregeln für Open Source (Microsoft Open Source Code of Conduct). Weitere Informationen finden Sie in den häufig gestellten Fragen zum Verhaltenskodex. Sie können sich auch an opencode@microsoft.com wenden, wenn Sie weitere Fragen oder Kommentare haben.

Share via