Biblioteca de clientes do Razão Confidencial do Azure para Python – versão 1.1.1

Artigo
08/11/2023

O Razão Confidencial do Azure fornece um serviço para fazer logon em um razão imutável e à prova de adulteração. Como parte do portfólio de Computação Confidencial do Azure , o Razão Confidencial do Azure é executado em ambientes de execução confiáveis seguros e baseados em hardware, também conhecidos como enclaves. Ele é criado na Estrutura de Consórcio Confidencial da Microsoft Research.

Código-fonte | Pacote (PyPI) | Pacote (Conda) | Documentação | de referência da API Documentação do produto

Introdução

Instalar Pacotes

Instale azure-confidentialledger e azure-identity com pip:

pip install azure-identity azure-confidentialledger

azure-identity é usado para autenticação do Azure Active Directory, conforme demonstrado abaixo.

Pré-requisitos

Uma assinatura do Azure
Python 3.6 ou posterior
Uma instância em execução do Razão Confidencial do Azure.
Um usuário registrado no Razão Confidencial, normalmente atribuído durante a criação de recursos do ARM , com Administrator privilégios.

Autenticar o cliente

Como usar o Azure Active Directory

Este documento demonstra o uso de DefaultAzureCredential para autenticar no Razão Confidencial por meio do Azure Active Directory. No entanto, ConfidentialLedgerClient aceita qualquer credencial de identidade do azure . Consulte a documentação azure-identity para obter mais informações sobre outras credenciais.

Usando um certificado de cliente

Como alternativa ao Azure Active Directory, os clientes podem optar por usar um certificado de cliente para autenticar por meio do TLS mútuo. azure.confidentialledger.ConfidentialLedgerCertificateCredential pode ser usado para essa finalidade.

Criar um cliente

DefaultAzureCredential lidará automaticamente com a maioria dos cenários de cliente do SDK do Azure. Para começar, defina variáveis de ambiente para a identidade do AAD registrada com seu Razão Confidencial.

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

Em seguida, DefaultAzureCredential será capaz de autenticar o ConfidentialLedgerClient.

A construção do cliente também requer a URL e a ID do Razão Confidencial, que você pode obter da CLI do Azure ou do Portal do Azure. Quando você tiver recuperado esses valores, substitua instâncias de "my-ledger-id" e "https://my-ledger-id.confidential-ledger.azure.com" nos exemplos abaixo. Talvez você também precise substituir "https://identity.confidential-ledger.core.azure.com" pelo nome do host na descrição identityServiceUri do ARM do seu razão.

Como os Razãos Confidenciais usam certificados autoassinados gerados e armazenados com segurança em um enclave, o certificado de autenticação para cada Razão Confidencial deve primeiro ser recuperado do Serviço de Identidade do Razão Confidencial.

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
)

Convenientemente, o ConfidentialLedgerClient construtor buscará o certificado TLS do razão (e o gravará no arquivo especificado) se ele for fornecido com um arquivo inexistente. O usuário é responsável por remover o arquivo criado conforme necessário.

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

Para deixar claro que um arquivo está sendo usado para o certificado TLS do razão, os exemplos subsequentes gravarão explicitamente o certificado TLS do razão em um arquivo.

Principais conceitos

Entradas e transações do razão

Cada gravação no Razão Confidencial do Azure gera uma entrada de razão imutável no serviço. As gravações, também conhecidas como transações, são identificadas exclusivamente por IDs de transação que incrementam com cada gravação. Depois de gravadas, as entradas do razão podem ser recuperadas a qualquer momento.

Coleções

Embora a maioria dos casos de uso envolva apenas uma coleção por Razão Confidencial, fornecemos o recurso de ID de coleção caso grupos de dados semanticamente ou logicamente diferentes precisem ser armazenados no mesmo Razão Confidencial.

As entradas do razão são recuperadas por seu collectionId. O Razão Confidencial sempre assumirá uma constante determinada pelo serviço collectionId para entradas gravadas sem um collectionId especificado.

Usuários

Os usuários são gerenciados diretamente com o Razão Confidencial em vez de por meio do Azure. Os usuários podem ser baseados em AAD, identificados por sua ID de objeto do AAD ou com base em certificado, identificados pela impressão digital do certificado PEM.

Recebimentos

Para impor garantias de integridade de transação, um Razão Confidencial do Azure usa uma estrutura de dados [Árvore merkle][merkle_tree_wiki] para registrar o hash de todos os blocos de transações que são acrescentados ao razão imutável. Depois que uma transação de gravação é confirmada, os usuários do Razão Confidencial do Azure podem obter uma prova criptográfica do Merkle, ou recibo, sobre a entrada produzida em um Razão Confidencial para verificar se a operação de gravação foi salva corretamente. Um recibo de transação de gravação é a prova de que o sistema confirmou a transação correspondente e pode ser usado para verificar se a entrada foi efetivamente acrescentada ao Razão.

Consulte o artigo a seguir para obter mais informações sobre recibos de transação de gravação do Razão Confidencial do Azure.

Verificação de recibo

Depois de obter um recibo de uma transação de gravação, os usuários do Razão Confidencial do Azure podem verificar o conteúdo do recibo buscado após um algoritmo de verificação. O sucesso da verificação é a prova de que a operação de gravação associada ao recibo foi acrescentada corretamente ao razão imutável.

Consulte o artigo a seguir para obter mais informações sobre o processo de verificação para recibos de transação de gravação do Razão Confidencial do Azure.

Declarações de aplicativo

Os aplicativos do Razão Confidencial do Azure podem anexar dados arbitrários, chamados de declarações de aplicativo, para gravar transações. Essas declarações representam as ações executadas durante uma operação de gravação. Quando anexado a uma transação, o resumo SHA-256 do objeto de declarações é incluído no razão e confirmado como parte da transação de gravação. Isso garante que o resumo esteja conectado e não possa ser adulterado.

Posteriormente, as declarações de aplicativo podem ser reveladas em seu formulário não digerido no conteúdo do recibo correspondente à mesma transação em que foram adicionadas. Isso permite que os usuários aproveitem as informações no recibo para computar novamente o mesmo resumo de declarações que foi anexado e conectado pela instância do Razão Confidencial do Azure durante a transação. O resumo de declarações pode ser usado como parte do processo de verificação de confirmação de transação de gravação, fornecendo uma maneira offline para que os usuários verifiquem totalmente a autenticidade das declarações registradas.

Mais detalhes sobre o formato de declarações do aplicativo e o algoritmo de computação de resumo podem ser encontrados nos seguintes links:

Consulte as seguintes páginas de documentação do CCF para obter mais informações sobre declarações de aplicativo CCF:

Computação Confidencial

A Computação Confidencial do Azure permite isolar e proteger seus dados enquanto eles estão sendo processados na nuvem. O Razão Confidencial do Azure é executado em máquinas virtuais de Computação Confidencial do Azure, fornecendo proteção de dados mais forte com criptografia de dados em uso.

Estrutura do Consórcio Confidencial

O Razão Confidencial do Azure é criado no CCF (Confidential Consortium Framework) de software livre da Microsoft Research. No CCF, os aplicativos são gerenciados por um consórcio de membros com a capacidade de enviar propostas para modificar e controlar a operação de aplicativos. No Razão Confidencial do Azure, o Microsoft Azure possui uma identidade de membro do operador que permite executar ações de governança e manutenção, como substituir nós não íntegros no Razão Confidencial e atualizar o código de enclave.

Exemplos

Esta seção contém snippets de código que abrangem tarefas comuns, incluindo:

Acrescentar entrada
Recuperando entradas do razão
Fazendo uma consulta de intervalo
Managing users
Usando a autenticação de certificado
Verificar a gravação de recibos de transação

Acrescentar entrada

Os dados que precisam ser armazenados imutavelmente de maneira à prova de adulteração podem ser salvos no Razão Confidencial do Azure acrescentando uma entrada ao razão.

Como o Razão Confidencial é um sistema distribuído, falhas transitórias raras podem fazer com que as gravações sejam perdidas. Para entradas que devem ser preservadas, é aconselhável verificar se a gravação se tornou durável. Para gravações menos importantes em que a taxa de transferência do cliente mais alta é preferencial, a etapa de espera pode ser ignorada.

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

Como alternativa, o cliente pode aguardar o commit ao gravar uma entrada do razão.

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

Recuperando entradas do razão

Obter entradas do razão mais antigas do que as mais recentes pode levar algum tempo, pois o serviço está carregando entradas históricas, portanto, um sondador é fornecido.

As entradas do razão são recuperadas pela coleção. O valor retornado é o valor contido na coleção especificada no ponto no tempo identificado pela ID da transação.

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

Fazendo uma consulta de intervalo

As entradas do razão podem ser recuperadas em um intervalo de IDs de transação. As entradas só serão retornadas da coleção padrão ou especificada.

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

Managing users

Os usuários com Administrator privilégios podem gerenciar usuários do Razão Confidencial diretamente com o próprio Razão Confidencial. As funções disponíveis são Reader (somente leitura), Contributor (leitura e gravação) e Administrator (ler, gravar e adicionar ou remover usuários).

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)

Usando a autenticação de certificado

Os clientes podem se autenticar com um certificado de cliente no TLS mútuo em vez de por meio de um token do Azure Active Directory. ConfidentialLedgerCertificateCredential é fornecido para esses clientes.

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
)

Verificar a gravação de recibos de transação

Os clientes podem aproveitar a biblioteca de verificação de recibo no SDK para verificar os recibos de transação de gravação emitidos por instâncias do Legder Confidencial do Azure. O utilitário pode ser usado para verificar totalmente os recibos offline, pois o algoritmo de verificação não precisa estar conectado a um razão confidencial ou a qualquer outro serviço do Azure.

Depois que uma nova entrada tiver sido acrescentada ao razão (consulte este exemplo), é possível obter um recibo para a transação de gravação confirmada.

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

Depois de buscar um recibo de uma transação de gravação, é possível chamar a verify_receipt função para verificar se o recibo é válido. A função pode aceitar uma lista opcional de declarações de aplicativo para verificar no resumo das declarações de recibo.

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

Um programa python de exemplo completo que mostra como acrescentar uma nova entrada a uma instância do Razão Confidencial em execução, obter um recibo para a transação confirmada e verificar se o conteúdo do recibo pode ser encontrado na pasta de exemplos : get_and_verify_receipt.py.

API assíncrona

Essa biblioteca inclui uma API assíncrona completa com suporte no Python 3.5+. Para usá-lo, primeiro você deve instalar um transporte assíncrono, como aiohttp. Consulte a documentação do azure-core para obter mais informações.

Um cliente assíncrono é obtido de azure.confidentialledger.aio. Os métodos têm os mesmos nomes e assinaturas que o cliente síncrono. Exemplos podem ser encontrados aqui.

Solução de problemas

Geral

Os clientes do Razão Confidencial geram exceções definidas no azure-core. Por exemplo, se você tentar obter uma transação que não existe, ConfidentialLedgerClient gerará 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)

Log

Essa biblioteca usa a biblioteca de log padrão para registro em log. Informações básicas sobre sessões HTTP (URLs, cabeçalhos etc.) são registradas no nível INFO.

O log detalhado do nível de DEBUG, incluindo corpos de solicitação/resposta e cabeçalhos não redigidos, pode ser habilitado em um cliente com o logging_enable argumento :

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

Da mesma forma, logging_enable pode habilitar o log detalhado para uma operação individual, mesmo quando ela não está habilitada para o cliente:

ledger_client.get_current_ledger_entry(logging_enable=True)

Próximas etapas

Mais códigos de exemplo

Esses exemplos de código mostram operações de cenário comuns com a biblioteca de clientes do Razão Confidencial do Azure.

Cenários comuns

Gravando no razão:
- write_to_ledger.py
- write_to_ledger_async.py (versão assíncrona)
Escreva muitas entradas do razão e recupere todas elas posteriormente:
- list_ledger_entries.py
- list_ledger_entries_async.py (versão assíncrona)
Gerenciar usuários usando o controle de acesso baseado em função implementado pelo serviço:
- manage_users.py
- manage_users_async.py (versão assíncrona)

Cenários avançados

Usando coleções:
- use_collections.py
- use_collections_async.py (versão assíncrona)
Obtendo recibos para gravações do razão:
- get_receipt.py
- get_receipt_async.py (versão assíncrona)
Verificando os detalhes do serviço:
- verify_service.py
- verify_service_async.py (versão assíncrona)

Documentação Adicional

Para obter uma documentação mais abrangente sobre o Razão Confidencial do Azure, consulte a documentação de referência da API. Você também pode ler mais sobre a Estrutura de Consórcio Confidencial de software livre da Microsoft Research.

Contribuição

Este projeto aceita contribuições e sugestões. A maioria das contribuições exige que você concorde com um CLA (Contrato de Licença do Colaborador) declarando que você tem o direito de nos conceder, e de fato concede, os direitos de usar sua contribuição. Para obter detalhes, visite https://cla.microsoft.com.

Quando você envia uma solicitação de pull, um bot do CLA determina automaticamente se você precisa fornecer um CLA e preencher a PR corretamente (por exemplo, rótulo, comentário). Basta seguir as instruções fornecidas pelo bot. Você só precisará fazer isso uma vez em todos os repositórios que usam nosso CLA.

Este projeto adotou o Código de Conduta de Software Livre da Microsoft. Para obter mais informações, confira as Perguntas frequentes sobre o código de conduta ou entre em contato com opencode@microsoft.com para enviar outras perguntas ou comentários.

Compartilhar via