Azure Confidential Ledger-clientbibliotheek voor Python - versie 1.1.1

Artikel
08/11/2023

Azure Confidential Ledger biedt een service voor logboekregistratie in een onveranderbaar, manipulatiebestendig grootboek. Als onderdeel van het Azure Confidential Computing-portfolio wordt Azure Confidential Ledger uitgevoerd in beveiligde, op hardware gebaseerde vertrouwde uitvoeringsomgevingen, ook wel enclaves genoemd. Het is gebaseerd op het Confidential Consortium Framework van Microsoft Research.

Broncode | Pakket (PyPI) | Pakket (Conda) | API-referentiedocumentatie | Productdocumentatie

Aan de slag

Pakketten installeren

Installeer azure-confidentialledger en azure-identity met pip:

pip install azure-identity azure-confidentialledger

azure-identity wordt gebruikt voor Azure Active Directory-verificatie, zoals hieronder wordt weergegeven.

Vereisten

Een Azure-abonnement
Python 3.6 of hoger
Een actief exemplaar van Azure Confidential Ledger.
Een geregistreerde gebruiker in het vertrouwelijke grootboek, die doorgaans wordt toegewezen tijdens het maken van EEN ARM-resource , met Administrator bevoegdheden.

De client verifiëren

Azure Active Directory gebruiken

In dit document wordt gedemonstreerd hoe u DefaultAzureCredential gebruikt voor verificatie bij het vertrouwelijke grootboek via Azure Active Directory. Accepteert echter ConfidentialLedgerClient alle azure-identity-referenties . Zie de documentatie over azure-identity voor meer informatie over andere referenties.

Een clientcertificaat gebruiken

Als alternatief voor Azure Active Directory kunnen clients ervoor kiezen om een clientcertificaat te gebruiken voor verificatie via wederzijdse TLS. azure.confidentialledger.ConfidentialLedgerCertificateCredential mogen voor dit doel worden gebruikt.

Client maken

DefaultAzureCredential verwerkt automatisch de meeste Azure SDK-clientscenario's. Stel eerst omgevingsvariabelen in voor de AAD-identiteit die is geregistreerd bij uw vertrouwelijk grootboek.

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

DefaultAzureCredential Vervolgens kan de ConfidentialLedgerClientworden geverifieerd.

Voor het samenstellen van de client zijn ook de URL en id van uw Confidential Ledger vereist, die u kunt ophalen uit de Azure CLI of de Azure-portal. Wanneer u deze waarden hebt opgehaald, vervangt u exemplaren van "my-ledger-id" en "https://my-ledger-id.confidential-ledger.azure.com" in de onderstaande voorbeelden. Mogelijk moet u ook vervangen door "https://identity.confidential-ledger.core.azure.com" de hostnaam uit de identityServiceUri in de ARM-beschrijving van uw grootboek.

Omdat vertrouwelijke grootboeken gebruikmaken van zelfondertekende certificaten die veilig zijn gegenereerd en opgeslagen in een enclave, moet het handtekeningcertificaat voor elk vertrouwelijk grootboek eerst worden opgehaald uit de Confidential Ledger Identity Service.

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
)

Handig is dat de ConfidentialLedgerClient constructor het TLS-certificaat van het grootboek ophaalt (en naar het opgegeven bestand schrijft) als het wordt geleverd met een niet-bestaand bestand. De gebruiker is verantwoordelijk voor het verwijderen van het gemaakte bestand indien nodig.

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

Om duidelijk te maken dat er een bestand wordt gebruikt voor het TLS-certificaat van het grootboek, wordt in volgende voorbeelden het TLS-certificaat van het grootboek expliciet naar een bestand geschreven.

Belangrijkste concepten

Grootboekposten en transacties

Elke schrijfbewerking naar Azure Confidential Ledger genereert een onveranderbare grootboekvermelding in de service. Schrijfbewerkingen, ook wel transacties genoemd, worden uniek geïdentificeerd door transactie-id's die met elke schrijfbewerking worden verhoogd. Eenmaal geschreven, kunnen grootboekvermeldingen op elk gewenst moment worden opgehaald.

Verzamelingen

Hoewel de meeste use cases slechts één verzameling per vertrouwelijk grootboek omvatten, bieden we de functie verzamelings-id voor het geval semantisch of logisch verschillende groepen gegevens moeten worden opgeslagen in hetzelfde vertrouwelijke grootboek.

Grootboekvermeldingen worden opgehaald door hun collectionId. Het vertrouwelijk grootboek gaat altijd uit van een constante, service die is bepaald collectionId voor vermeldingen die zijn geschreven zonder een collectionId opgegeven.

Gebruikers

Gebruikers worden rechtstreeks beheerd met het vertrouwelijke grootboek in plaats van via Azure. Gebruikers kunnen zijn gebaseerd op AAD, geïdentificeerd door hun AAD-object-id, of op certificaten gebaseerd, geïdentificeerd door hun PEM-certificaatvingerafdruk.

Ontvangsten

Om garanties voor transactie-integriteit af te dwingen, gebruikt een Azure Confidential Ledger een gegevensstructuur [Merkle tree][merkle_tree_wiki] om de hash vast te leggen van alle transactieblokken die zijn toegevoegd aan het onveranderbare grootboek. Nadat een schrijftransactie is doorgevoerd, kunnen gebruikers van Azure Confidential Ledger een cryptografisch Merkle-bewijs of ontvangstbewijs krijgen voor de vermelding die is geproduceerd in een vertrouwelijk grootboek om te controleren of de schrijfbewerking correct is opgeslagen. Een ontvangstbewijs van een schrijftransactie is het bewijs dat het systeem de bijbehorende transactie heeft doorgevoerd en kan worden gebruikt om te controleren of de vermelding effectief aan het grootboek is toegevoegd.

Raadpleeg het volgende artikel voor meer informatie over schrijfbevestigingen van Azure Confidential Ledger.

Ontvangstverificatie

Nadat gebruikers van Azure Confidential Ledger een ontvangstbewijs voor een schrijftransactie hebben ontvangen, kunnen ze de inhoud van het opgehaalde ontvangstbewijs controleren met behulp van een verificatie-algoritme. Het succes van de verificatie is het bewijs dat de schrijfbewerking die is gekoppeld aan het ontvangstbewijs correct is toegevoegd aan het onveranderbare grootboek.

Raadpleeg het volgende artikel voor meer informatie over het verificatieproces voor Azure Confidential Ledger-transactieontvangsten.

Toepassingsclaims

Azure Confidential Ledger-toepassingen kunnen willekeurige gegevens, ook wel toepassingsclaims genoemd, koppelen aan het schrijven van transacties. Deze claims vertegenwoordigen de acties die worden uitgevoerd tijdens een schrijfbewerking. Wanneer deze is gekoppeld aan een transactie, wordt de SHA-256-samenvatting van het claimobject opgenomen in het grootboek en vastgelegd als onderdeel van de schrijftransactie. Dit garandeert dat de samenvatting is ondertekend en niet kan worden gemanipuleerd.

Later kunnen toepassingsclaims worden weergegeven in hun niet-verwerkte vorm in de nettolading van het ontvangstbewijs die overeenkomt met dezelfde transactie waar ze zijn toegevoegd. Hierdoor kunnen gebruikers de informatie in de ontvangstbevestiging gebruiken om dezelfde claimsamenvating opnieuw te berekenen die tijdens de transactie is gekoppeld en aangemeld door het Azure Confidential Ledger-exemplaar. De claimsamenvating kan worden gebruikt als onderdeel van het verificatieproces voor de ontvangst van schrijftransacties, waardoor gebruikers offline de echtheid van de vastgelegde claims volledig kunnen verifiëren.

Meer informatie over de indeling van toepassingsclaims en het algoritme voor digest-berekening vindt u via de volgende koppelingen:

Raadpleeg de volgende CCF-documentatiepagina's voor meer informatie over CCF-toepassingsclaims:

Confidential Computing

Met Azure Confidential Computing kunt u uw gegevens isoleren en beveiligen terwijl deze in de cloud worden verwerkt. Azure Confidential Ledger wordt uitgevoerd op virtuele machines van Azure Confidential Computing en biedt zo een betere gegevensbeveiliging met versleuteling van gegevens die in gebruik zijn.

Confidential Consortium Framework

Azure Confidential Ledger is gebaseerd op het opensource Confidential Consortium Framework (CCF) van Microsoft Research. Onder CCF worden toepassingen beheerd door een consortium van leden met de mogelijkheid om voorstellen in te dienen om de toepassingsbewerking te wijzigen en te beheren. In Azure Confidential Ledger is Microsoft Azure eigenaar van een operatorlididentiteit waarmee beheer- en onderhoudsacties kunnen worden uitgevoerd, zoals het vervangen van beschadigde knooppunten in het vertrouwelijke grootboek en het upgraden van de enclavecode.

Voorbeelden

Deze sectie bevat codefragmenten voor algemene taken, waaronder:

Invoer toevoegen
Grootboekvermeldingen ophalen
Een bereikquery maken
Gebruikers beheren
Certificaatverificatie gebruiken
Ontvangstbewijzen voor schrijftransacties controleren

Invoer toevoegen

Gegevens die onveranderbaar op een manipulatiebestendige manier moeten worden opgeslagen, kunnen worden opgeslagen in Azure Confidential Ledger door een vermelding toe te voegen aan het grootboek.

Aangezien Vertrouwelijk grootboek een gedistribueerd systeem is, kunnen zeldzame tijdelijke fouten ertoe leiden dat schrijfbewerkingen verloren gaan. Voor vermeldingen die moeten worden bewaard, is het raadzaam om te controleren of de schrijfbewerking duurzaam is geworden. Voor minder belangrijke schrijfbewerkingen waarbij hogere clientdoorvoer de voorkeur heeft, kan de wachtstap worden overgeslagen.

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

De client kan ook wachten op doorvoer bij het schrijven van een grootboekvermelding.

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

Grootboekvermeldingen ophalen

Het ophalen van grootboekvermeldingen die ouder zijn dan de laatste kan enige tijd duren omdat de service historische vermeldingen laadt, dus er wordt een poller opgegeven.

Grootboekvermeldingen worden opgehaald door verzameling. De geretourneerde waarde is de waarde in de opgegeven verzameling op het tijdstip dat wordt geïdentificeerd door de transactie-id.

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

Een bereikquery maken

Grootboekposten kunnen worden opgehaald via een reeks transactie-id's. Vermeldingen worden alleen geretourneerd vanuit de standaardverzameling of de opgegeven verzameling.

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

Gebruikers beheren

Gebruikers met Administrator bevoegdheden kunnen gebruikers van het vertrouwelijk grootboek rechtstreeks beheren met het vertrouwelijke grootboek zelf. Beschikbare rollen zijn Reader (alleen-lezen), Contributor (lezen en schrijven) en Administrator (lezen, schrijven en gebruikers toevoegen of verwijderen).

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)

Certificaatverificatie gebruiken

Clients kunnen zich verifiëren met een clientcertificaat in wederzijdse TLS in plaats van via een Azure Active Directory-token. ConfidentialLedgerCertificateCredential wordt verstrekt voor dergelijke klanten.

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
)

Ontvangstbewijzen voor schrijftransacties verifiëren

Clients kunnen gebruikmaken van de verificatiebibliotheek voor ontvangstbewijzen in de SDK om ontvangstbewijzen voor schrijftransacties te controleren die zijn uitgegeven door Azure Confidential Legder-exemplaren. Het hulpprogramma kan worden gebruikt om ontvangstbewijzen volledig offline te verifiëren, omdat het verificatie-algoritme niet hoeft te zijn verbonden met een vertrouwelijk grootboek of een andere Azure-service.

Zodra een nieuwe vermelding is toegevoegd aan het grootboek (raadpleeg dit voorbeeld), is het mogelijk om een ontvangstbewijs voor de vastgelegde schrijftransactie te krijgen.

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

Nadat u een ontvangstbewijs voor een schrijftransactie hebt opgehaald, kunt u de verify_receipt functie aanroepen om te controleren of het ontvangstbewijs geldig is. De functie kan een optionele lijst met toepassingsclaims accepteren om te controleren op basis van de samenvatting van ontvangstclaims.

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

Een volledig Python-voorbeeldprogramma dat laat zien hoe u een nieuwe vermelding toevoegt aan een actief exemplaar van vertrouwelijk grootboek, een ontvangstbewijs voor de vastgelegde transactie opkrijgt en controleert of de inhoud van de ontvangstbevestiging te vinden is in de map met voorbeelden : get_and_verify_receipt.py.

Async-API

Deze bibliotheek bevat een volledige asynchrone API die wordt ondersteund in Python 3.5+. Als u deze wilt gebruiken, moet u eerst een asynchroon transport installeren, zoals aiohttp. Zie de documentatie voor azure-core voor meer informatie.

Er wordt een asynchrone client verkregen van azure.confidentialledger.aio. Methoden hebben dezelfde namen en handtekeningen als de synchrone client. Voorbeelden vindt u hier.

Problemen oplossen

Algemeen

Confidential Ledger-clients genereren uitzonderingen die zijn gedefinieerd in azure-core. Als u bijvoorbeeld een transactie probeert op te halen die niet bestaat, ConfidentialLedgerClient wordt ResourceNotFoundError gegenereerd:

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)

Logboekregistratie

Deze bibliotheek gebruikt de standaardbibliotheek voor logboekregistratie voor logboekregistratie. Basisinformatie over HTTP-sessies (URL's, headers, enzovoort) wordt geregistreerd op INFO-niveau.

Gedetailleerde logboekregistratie op foutopsporingsniveau, inclusief aanvraag-/antwoordteksten en niet-geredigeerde headers, kan worden ingeschakeld op een client met het logging_enable argument:

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

Op dezelfde manier kan logging_enable logboekregistratie voor één bewerking inschakelen, zelfs wanneer dit niet is ingeschakeld voor de client:

ledger_client.get_current_ledger_entry(logging_enable=True)

Volgende stappen

Meer voorbeeldcode

Deze codevoorbeelden tonen algemene scenariobewerkingen met de Clientbibliotheek van Azure Confidential Ledger.

Algemene scenario's

Schrijven naar het grootboek:
- write_to_ledger.py
- write_to_ledger_async.py (asynchrone versie)
Schrijf veel grootboekvermeldingen en haal ze daarna allemaal op:
- list_ledger_entries.py
- list_ledger_entries_async.py (asynchrone versie)
Gebruikers beheren met behulp van door de service geïmplementeerd toegangsbeheer op basis van rollen:
- manage_users.py
- manage_users_async.py (asynchrone versie)

Geavanceerde scenario's

Verzamelingen gebruiken:
- use_collections.py
- use_collections_async.py (asynchrone versie)
Ontvangstbevestigingen voor grootboekschrijfbewerkingen:
- get_receipt.py
- get_receipt_async.py (asynchrone versie)
Servicedetails controleren:
- verify_service.py
- verify_service_async.py (asynchrone versie)

Aanvullende documentatie

Zie de API-referentiedocumentatie voor uitgebreidere documentatie over Azure Confidential Ledger. U kunt ook meer lezen over het opensource Confidential Consortium Framework van Microsoft Research.

Bijdragen

Wij verwelkomen bijdragen en suggesties voor dit project. Voor de meeste bijdragen moet u instemmen met een licentieovereenkomst voor bijdragers (CLA: Contributor License Agreement) waarin u verklaart dat u gerechtigd bent ons het recht te geven uw bijdrage te gebruiken, en dat u dit ook doet. Ga naar https://cla.microsoft.com voor meer informatie.

Wanneer u een pull-aanvraag indient, wordt met een CLA-bot automatisch bepaald of u een CLA moet verschaffen en wordt de pull-aanvraag dienovereenkomstig opgemaakt (bijvoorbeeld met een label of commentaar). Volg gewoon de instructies van de bot. U hoeft dit maar eenmaal te doen voor alle repo's waar gebruik wordt gemaakt van onze CLA.

Op dit project is de Microsoft Open Source Code of Conduct (Microsoft Open Source-gedragscode) van toepassing. Raadpleeg de Veelgestelde vragen over de gedragscode voor meer informatie of neem contact op met opencode@microsoft.com als u meer vragen of opmerkingen hebt.

Delen via