Tutorial: Verwenden des Microsoft Purview Python SDK

In diesem Tutorial lernen Sie die Verwendung des Microsoft Purview Python SDK kennen. Sie können das SDK verwenden, um alle gängigsten Microsoft Purview-Vorgänge programmgesteuert und nicht über das Microsoft Purview-Governanceportal durchzuführen.

In diesem Tutorial erfahren Sie, wie sie mit dem SDK:

Voraussetzungen

Für dieses Tutorial benötigen Sie Folgendes:

• Python 3.6 oder höher
• Ein aktives Azure-Abonnement. Wenn Sie noch keine haben, können Sie eine kostenlos erstellen.
• Ein Microsoft Entra Mandanten, der Ihrem Abonnement zugeordnet ist.
• Ein Azure Storage-Konto. Wenn Sie noch keines besitzen, können Sie unsere Schnellstartanleitung befolgen, um eine zu erstellen.
• Ein Microsoft Purview-Konto. Wenn Sie noch keines besitzen, können Sie unsere Schnellstartanleitung befolgen, um eine zu erstellen.
• Ein Dienstprinzipal mit einem geheimen Clientschlüssel.

Gewähren von Microsoft Purview-Zugriff auf das Speicherkonto

Bevor Sie den Inhalt des Speicherkontos überprüfen können, müssen Sie Microsoft Purview die richtige Rolle zuweisen.

1. Wechseln Sie über die Azure-Portal zu Ihrem Speicherkonto.

2. Wählen Sie Access Control (IAM) aus.

3. Wählen Sie die Schaltfläche Hinzufügen und dann Rollenzuweisung hinzufügen aus.

   

4. Suchen Sie im nächsten Fenster nach der Rolle Speicherblobleser , und wählen Sie sie aus:

   

5. Wechseln Sie dann zur Registerkarte Mitglieder, und wählen Sie Mitglieder auswählen aus:

   

6. Auf der rechten Seite wird ein neuer Bereich angezeigt. Suchen Sie den Namen Ihrer vorhandenen Microsoft Purview-instance, und wählen Sie sie aus.

7. Sie können dann Überprüfen + zuweisen auswählen.

Microsoft Purview verfügt jetzt über das erforderliche Leserecht, um Ihren Blob Storage zu überprüfen.

Gewähren Des Zugriffs auf Ihr Microsoft Purview-Konto für Ihre Anwendung

1. Zunächst benötigen Sie die Client-ID, die Mandanten-ID und den geheimen Clientschlüssel ihres Dienstprinzipals. Um diese Informationen zu finden, wählen Sie Ihre Microsoft Entra ID aus.

2. Wählen Sie dann App-Registrierungen aus.

3. Wählen Sie Ihre Anwendung aus, und suchen Sie die erforderlichen Informationen:

   • Name

   • Client-ID (oder Anwendungs-ID)

   • Mandanten-ID (oder Verzeichnis-ID)

     

   • Geheimer Clientschlüssel

     

4. Nun müssen Sie Ihrem Dienstprinzipal die relevanten Microsoft Purview-Rollen zuweisen. Greifen Sie dazu auf Ihre Microsoft Purview-instance zu. Wählen Sie Microsoft Purview-Governanceportal öffnen aus, oder öffnen Sie direkt das Governanceportal von Microsoft Purview, und wählen Sie die instance aus, die Sie bereitgestellt haben.

5. Wählen Sie im Microsoft Purview-Governanceportal data map und dann Sammlungen aus:

   

6. Wählen Sie die Sammlung aus, mit der Sie arbeiten möchten, und wechseln Sie zur Registerkarte Rollenzuweisungen . Fügen Sie den Dienstprinzipal in den folgenden Rollen hinzu:

   • Sammlungsadministratoren
   • Datenquellenadministratoren
   • Datenkuratoren
   • Datenleser

7. Wählen Sie für jede Rolle die Schaltfläche Rollenzuweisungen bearbeiten aus, und wählen Sie die Rolle aus, der Sie den Dienstprinzipal hinzufügen möchten. Oder wählen Sie die Schaltfläche Hinzufügen neben jeder Rolle aus, und fügen Sie den Dienstprinzipal hinzu, indem Sie den Namen oder die Client-ID wie unten gezeigt durchsuchen:

   

Installieren der Python-Pakete

1. Öffnen einer neuen Eingabeaufforderung oder eines neuen Terminals
2. Installieren Sie das Azure-Identitätspaket für die Authentifizierung:

   pip install azure-identity
   

3. Installieren Sie das Microsoft Purview Scanning Client-Paket:

   pip install azure-purview-scanning
   

4. Installieren Sie das Microsoft Purview-Verwaltungsclientpaket:

   pip install azure-purview-administration
   

5. Installieren Sie das Microsoft Purview-Clientpaket:

   pip install azure-purview-catalog
   

6. Installieren Sie das Microsoft Purview-Kontopaket:

   pip install azure-purview-account
   

7. Installieren Sie das Azure Core-Paket:

   pip install azure-core
   

Erstellen einer Python-Skriptdatei

Erstellen Sie eine Nur-Text-Datei, und speichern Sie sie als Python-Skript mit dem Suffix .py. Beispiel: tutorial.py.

Instanziieren eines Scan-, Katalog- und Verwaltungsclients

In diesem Abschnitt erfahren Sie, wie Sie Folgendes instanziieren:

• Ein Überprüfungsclient, der nützlich ist, um Datenquellen zu registrieren, Überprüfungsregeln zu erstellen und zu verwalten, eine Überprüfung auszulösen usw.
• Ein Katalogclient, der für die Interaktion mit dem Katalog nützlich ist, indem Sie suchen, die ermittelten Ressourcen durchsuchen, die Vertraulichkeit Ihrer Daten identifizieren usw.
• Ein Verwaltungsclient ist nützlich für die Interaktion mit dem Microsoft Purview Data Map selbst für Vorgänge wie das Auflisten von Sammlungen.

Zuerst müssen Sie sich bei Ihrem Microsoft Entra ID authentifizieren. Dazu verwenden Sie den geheimen Clientschlüssel, den Sie erstellt haben.

1. Beginnen Sie mit erforderlichen Importanweisungen: unsere drei Clients, die Credentials-Anweisung und eine Azure-Ausnahmeanweisung.

   from azure.purview.scanning import PurviewScanningClient
   from azure.purview.catalog import PurviewCatalogClient
   from azure.purview.administration.account import PurviewAccountClient
   from azure.identity import ClientSecretCredential 
   from azure.core.exceptions import HttpResponseError
   

2. Geben Sie die folgenden Informationen im Code an:

   • Client-ID (oder Anwendungs-ID)
   • Mandanten-ID (oder Verzeichnis-ID)
   • Geheimer Clientschlüssel

   client_id = "<your client id>" 
   client_secret = "<your client secret>"
   tenant_id = "<your tenant id>"
   

3. Geben Sie Ihren Endpunkt an:

   Wichtig

   Ihr Endpunktwert unterscheidet sich je nachdem, welches Microsoft Purview-Portal Sie verwenden. Endpunkt für das klassische Microsoft Purview-Governanceportal: https://{your_purview_account_name}.purview.azure.com/ Endpunkt für das neue Microsoft Purview-Portal: https://api.purview-service.microsoft.com

   Überprüfen des Endpunkts für das klassische Microsoft Purview-Governanceportal: https://{your_purview_account_name}.scan.purview.azure.com/ Endpunkt für das neue Microsoft Purview-Portal: https://api.scan.purview-service.microsoft.com

   purview_endpoint = "<endpoint>"
   
   purview_scan_endpoint = "<scan endpoint>"
   

4. Sie können jetzt die drei Clients instanziieren:

   def get_credentials():
       credentials = ClientSecretCredential(client_id=client_id, client_secret=client_secret, tenant_id=tenant_id)
       return credentials
   
   def get_purview_client():
       credentials = get_credentials()
       client = PurviewScanningClient(endpoint=purview_scan_endpoint, credential=credentials, logging_enable=True)  
       return client
   
   def get_catalog_client():
       credentials = get_credentials()
       client = PurviewCatalogClient(endpoint=purview_endpoint, credential=credentials, logging_enable=True)
       return client
   
   def get_admin_client():
       credentials = get_credentials()
       client = PurviewAccountClient(endpoint=purview_endpoint, credential=credentials, logging_enable=True)
       return client
   

Viele unserer Skripts beginnen mit diesen Schritten, da wir diese Clients für die Interaktion mit dem Konto benötigen.

Registrieren einer Datenquelle

In diesem Abschnitt registrieren Sie Ihren Blob Storage.

1. Wie im vorherigen Abschnitt erläutert, importieren Sie zunächst die Clients, die Sie für den Zugriff auf Ihr Microsoft Purview-Konto benötigen. Importieren Sie außerdem das Azure-Fehlerantwortpaket, damit Sie die Problembehandlung durchführen können, und die ClientSecretCredential-Instanz, um Ihre Azure-Anmeldeinformationen zu erstellen.

   from azure.purview.administration.account import PurviewAccountClient
   from azure.purview.scanning import PurviewScanningClient
   from azure.core.exceptions import HttpResponseError
   from azure.identity import ClientSecretCredential
   

2. Ermitteln Sie die Ressourcen-ID für Ihr Speicherkonto anhand dieser Anleitung: Abrufen der Ressourcen-ID für ein Speicherkonto.

3. Definieren Sie dann in Ihrer Python-Datei die folgenden Informationen, um blob storage programmgesteuert registrieren zu können:

   storage_name = "<name of your Storage Account>"
   storage_id = "<id of your Storage Account>"
   rg_name = "<name of your resource group>"
   rg_location = "<location of your resource group>"
   reference_name_purview = "<name of your Microsoft Purview account>"
   

4. Geben Sie den Namen der Sammlung an, in der Sie Ihren Blobspeicher registrieren möchten. (Es sollte dieselbe Sammlung sein, in der Sie zuvor Berechtigungen angewendet haben. Wenn dies nicht der Fall ist, wenden Sie zuerst Berechtigungen auf diese Sammlung an.) Wenn es sich um die Stammsammlung handelt, verwenden Sie denselben Namen wie Ihre Microsoft Purview-instance.

   collection_name = "<name of your collection>"
   

5. Erstellen Sie eine Funktion, um die Anmeldeinformationen für den Zugriff auf Ihr Microsoft Purview-Konto zu erstellen:

   client_id = "<your client id>" 
   client_secret = "<your client secret>"
   tenant_id = "<your tenant id>"
   
   
   def get_credentials():
        credentials = ClientSecretCredential(client_id=client_id, client_secret=client_secret, tenant_id=tenant_id)
        return credentials
   

6. Alle Sammlungen im Microsoft Purview Data Map haben einen Anzeigenamen und einen Namen.

   • Der Anzeigename ist der Name, der in der Sammlung angezeigt wird. Beispiel: Sales.
   • Der Name für alle Sammlungen (mit Ausnahme der Stammauflistung) ist ein von der Data Map zugewiesener Sechszeichenname.

   Python benötigt diesen sechsstelligen Namen, um auf untere Auflistungen zu verweisen. Fügen Sie diesen Codeblock hinzu, um Ihren Anzeigenamen automatisch in den namen der sechsstelligen Sammlung zu konvertieren, die in Ihrem Skript benötigt wird:

   Wichtig

   Ihr Endpunktwert unterscheidet sich je nachdem, welches Microsoft Purview-Portal Sie verwenden. Endpunkt für das klassische Microsoft Purview-Governanceportal: purview.azure.com/ Endpunkt für das neue Microsoft Purview-Portal: purview.microsoft.com/

   Wenn Sie also das neue Portal verwenden, lautet ihr Endpunktwert etwa wie folgt: "https://consotopurview.scan.purview.microsoft.com"

   def get_admin_client():
        credentials = get_credentials()
        client = PurviewAccountClient(endpoint=purview_endpoint, credential=credentials, logging_enable=True)
        return client
   
   try:
     admin_client = get_admin_client()
   except ValueError as e:
       print(e)
   
   collection_list = client.collections.list_collections()
    for collection in collection_list:
     if collection["friendlyName"].lower() == collection_name.lower():
         collection_name = collection["name"]
   

7. Für beide Clients und abhängig von den Vorgängen müssen Sie auch einen Eingabetext angeben. Um eine Quelle zu registrieren, müssen Sie einen Eingabetext für die Datenquellenregistrierung angeben:

   ds_name = "<friendly name for your data source>"
   
   body_input = {
           "kind": "AzureStorage",
           "properties": {
               "endpoint": f"https://{storage_name}.blob.core.windows.net/",
               "resourceGroup": rg_name,
               "location": rg_location,
               "resourceName": storage_name,
               "resourceId": storage_id,
               "collection": {
                   "type": "CollectionReference",
                   "referenceName": collection_name
               },
               "dataUseGovernance": "Disabled"
           }
   }    
   

8. Jetzt können Sie Ihre Microsoft Purview-Clients aufrufen und die Datenquelle registrieren.

   Wichtig

   Ihr Endpunktwert unterscheidet sich je nachdem, welches Microsoft Purview-Portal Sie verwenden. Endpunkt für das klassische Microsoft Purview-Governanceportal: https://{your_purview_account_name}.purview.azure.com/ Endpunkt für das neue Microsoft Purview-Portal: https://api.purview-service.microsoft.com

   Wenn Sie das klassische Portal verwenden, lautet ihr Endpunktwert wie folgt: https://{your_purview_account_name}.scan.purview.azure.com Wenn Sie das neue Portal verwenden, lautet ihr Endpunktwert: https://scan.api.purview-service.microsoft.com

   def get_purview_client():
        credentials = get_credentials()
        client = PurviewScanningClient(endpoint={{ENDPOINT}}, credential=credentials, logging_enable=True)  
        return client
   
   try:
       client = get_purview_client()
   except ValueError as e:
       print(e)
   
   try:
       response = client.data_sources.create_or_update(ds_name, body=body_input)
       print(response)
       print(f"Data source {ds_name} successfully created or updated")
   except HttpResponseError as e:
       print(e)
   

Wenn der Registrierungsprozess erfolgreich ist, sehen Sie eine angereicherte Textantwort vom Client.

In den folgenden Abschnitten überprüfen Sie die registrierte Datenquelle und durchsuchen den Katalog. Jedes dieser Skripts ist ähnlich strukturiert wie dieses Registrierungsskript.

Vollständiger Code

from azure.purview.scanning import PurviewScanningClient
from azure.identity import ClientSecretCredential 
from azure.core.exceptions import HttpResponseError
from azure.purview.administration.account import PurviewAccountClient

client_id = "<your client id>" 
client_secret = "<your client secret>"
tenant_id = "<your tenant id>"
purview_endpoint = "<endpoint>"
purview_scan_endpoint = "<scan endpoint>"
storage_name = "<name of your Storage Account>"
storage_id = "<id of your Storage Account>"
rg_name = "<name of your resource group>"
rg_location = "<location of your resource group>"
collection_name = "<name of your collection>"
ds_name = "<friendly data source name>"

def get_credentials():
	credentials = ClientSecretCredential(client_id=client_id, client_secret=client_secret, tenant_id=tenant_id)
	return credentials

def get_purview_client():
	credentials = get_credentials()
	client = PurviewScanningClient(endpoint=purview_scan_endpoint, credential=credentials, logging_enable=True)  
	return client

def get_admin_client():
	credentials = get_credentials()
	client = PurviewAccountClient(endpoint=purview_endpoint, credential=credentials, logging_enable=True)
	return client

try:
	admin_client = get_admin_client()
except ValueError as e:
        print(e)

collection_list = admin_client.collections.list_collections()
for collection in collection_list:
	if collection["friendlyName"].lower() == collection_name.lower():
		collection_name = collection["name"]


body_input = {
	"kind": "AzureStorage",
	"properties": {
		"endpoint": f"https://{storage_name}.blob.core.windows.net/",
		"resourceGroup": rg_name,
		"location": rg_location,
		"resourceName": storage_name,
 		"resourceId": storage_id,
		"collection": {
			"type": "CollectionReference",
			"referenceName": collection_name
		},
		"dataUseGovernance": "Disabled"
	}
}

try:
	client = get_purview_client()
except ValueError as e:
        print(e)

try:
	response = client.data_sources.create_or_update(ds_name, body=body_input)
	print(response)
	print(f"Data source {ds_name} successfully created or updated")
except HttpResponseError as e:
    print(e)

Überprüfen der Datenquelle

Das Überprüfen einer Datenquelle kann in zwei Schritten erfolgen:

1. Erstellen einer Scandefinition
2. Auslösen einer Überprüfungsausführung

In diesem Tutorial verwenden Sie die Standardüberprüfungsregeln für Blob Storage-Container. Sie können jedoch auch programmgesteuert benutzerdefinierte Überprüfungsregeln mit dem Microsoft Purview Scanning Client erstellen.

Nun überprüfen wir die datenquelle, die Sie oben registriert haben.

1. Fügen Sie eine Importanweisung hinzu, um einen eindeutigen Bezeichner zu generieren, rufen Sie den Microsoft Purview-Überprüfungsclient, den Microsoft Purview-Verwaltungsclient, das Azure-Fehlerantwortpaket für die Problembehandlung und die Anmeldeinformationen des geheimen Clientschlüssels auf, um Ihre Azure-Anmeldeinformationen zu erfassen.

   import uuid
   from azure.purview.scanning import PurviewScanningClient
   from azure.purview.administration.account import PurviewAccountClient
   from azure.core.exceptions import HttpResponseError
   from azure.identity import ClientSecretCredential 
   

2. Erstellen Sie einen Überprüfungsclient mit Ihren Anmeldeinformationen:

   client_id = "<your client id>" 
   client_secret = "<your client secret>"
   tenant_id = "<your tenant id>"
   
   def get_credentials():
        credentials = ClientSecretCredential(client_id=client_id, client_secret=client_secret, tenant_id=tenant_id)
        return credentials
   
   def get_purview_client():
        credentials = get_credentials()
        client = PurviewScanningClient(endpoint=f"https://{reference_name_purview}.scan.purview.azure.com", credential=credentials, logging_enable=True)  
        return client
   
   try:
        client = get_purview_client()
   except ValueError as e:
        print(e)
   

3. Fügen Sie den Code hinzu, um den internen Namen Ihrer Sammlung zu erfassen. (Weitere Informationen finden Sie im vorherigen Abschnitt):

   collection_name = "<name of the collection where you will be creating the scan>"
   
   def get_admin_client():
        credentials = get_credentials()
        client = PurviewAccountClient(endpoint=purview_endpoint, credential=credentials, logging_enable=True)
        return client
   
   try:
       admin_client = get_admin_client()
   except ValueError as e:
       print(e)
   
   collection_list = client.collections.list_collections()
    for collection in collection_list:
     if collection["friendlyName"].lower() == collection_name.lower():
         collection_name = collection["name"]
   

4. Erstellen Sie dann eine Scandefinition:

   ds_name = "<name of your registered data source>"
   scan_name = "<name of the scan you want to define>"
   reference_name_purview = "<name of your Microsoft Purview account>"
   
   body_input = {
           "kind":"AzureStorageMsi",
           "properties": { 
               "scanRulesetName": "AzureStorage", 
               "scanRulesetType": "System", #We use the default scan rule set 
               "collection": 
                   {
                       "referenceName": collection_name,
                       "type": "CollectionReference"
                   }
           }
   }
   
   try:
       response = client.scans.create_or_update(data_source_name=ds_name, scan_name=scan_name, body=body_input)
       print(response)
       print(f"Scan {scan_name} successfully created or updated")
   except HttpResponseError as e:
       print(e)
   

5. Nachdem die Überprüfung definiert wurde, können Sie eine Überprüfungsausführung mit einer eindeutigen ID auslösen:

   run_id = uuid.uuid4() #unique id of the new scan
   
   try:
       response = client.scan_result.run_scan(data_source_name=ds_name, scan_name=scan_name, run_id=run_id)
       print(response)
       print(f"Scan {scan_name} successfully started")
   except HttpResponseError as e:
       print(e)
   

Vollständiger Code

import uuid
from azure.purview.scanning import PurviewScanningClient
from azure.purview.administration.account import PurviewAccountClient
from azure.identity import ClientSecretCredential

ds_name = "<name of your registered data source>"
scan_name = "<name of the scan you want to define>"
reference_name_purview = "<name of your Microsoft Purview account>"
client_id = "<your client id>" 
client_secret = "<your client secret>"
tenant_id = "<your tenant id>"
collection_name = "<name of the collection where you will be creating the scan>"

def get_credentials():
	credentials = ClientSecretCredential(client_id=client_id, client_secret=client_secret, tenant_id=tenant_id)
	return credentials

def get_purview_client():
	credentials = get_credentials()
	client = PurviewScanningClient(endpoint=purview_scan_endpoint, credential=credentials, logging_enable=True)  
	return client

def get_admin_client():
	credentials = get_credentials()
	client = PurviewAccountClient(endpoint=purview_endpoint, credential=credentials, logging_enable=True)
	return client

try:
	admin_client = get_admin_client()
except ValueError as e:
        print(e)

collection_list = admin_client.collections.list_collections()
for collection in collection_list:
	if collection["friendlyName"].lower() == collection_name.lower():
		collection_name = collection["name"]


try:
	client = get_purview_client()
except AzureError as e:
	print(e)

body_input = {
	"kind":"AzureStorageMsi",
	"properties": { 
		"scanRulesetName": "AzureStorage", 
		"scanRulesetType": "System",
		"collection": {
			"type": "CollectionReference",
			"referenceName": collection_name
		}
	}
}

try:
	response = client.scans.create_or_update(data_source_name=ds_name, scan_name=scan_name, body=body_input)
	print(response)
	print(f"Scan {scan_name} successfully created or updated")
except HttpResponseError as e:
	print(e)

run_id = uuid.uuid4() #unique id of the new scan

try:
	response = client.scan_result.run_scan(data_source_name=ds_name, scan_name=scan_name, run_id=run_id)
	print(response)
	print(f"Scan {scan_name} successfully started")
except HttpResponseError as e:
	print(e)

Suchkatalog

Sobald eine Überprüfung abgeschlossen ist, ist es wahrscheinlich, dass Ressourcen ermittelt und sogar klassifiziert wurden. Dieser Prozess kann nach einer Überprüfung einige Zeit in Anspruch nehmen, sodass Sie möglicherweise warten müssen, bevor Sie diesen nächsten Teil des Codes ausführen. Warten Sie, bis die Überprüfung abgeschlossen und die Ressourcen in Microsoft Purview Unified Catalog angezeigt werden.

Sobald die Ressourcen bereit sind, können Sie den Microsoft Purview-Katalogclient verwenden, um den gesamten Katalog zu durchsuchen.

1. Dieses Mal müssen Sie den Katalogclient anstelle des Überprüfungsclients importieren. Schließen Sie auch den HTTPResponse-Fehler und ClientSecretCredential ein.

   from azure.purview.catalog import PurviewCatalogClient
   from azure.identity import ClientSecretCredential 
   from azure.core.exceptions import HttpResponseError
   

2. Erstellen Sie eine Funktion, um die Anmeldeinformationen für den Zugriff auf Ihr Microsoft Purview-Konto abzurufen, und instanziieren Sie den Katalogclient.

   client_id = "<your client id>" 
   client_secret = "<your client secret>"
   tenant_id = "<your tenant id>"
   reference_name_purview = "<name of your Microsoft Purview account>"
   
   def get_credentials():
        credentials = ClientSecretCredential(client_id=client_id, client_secret=client_secret, tenant_id=tenant_id)
        return credentials
   
   def get_catalog_client():
       credentials = get_credentials()
       client = PurviewCatalogClient(endpoint=f"https://{reference_name_purview}.scan.purview.azure.com", credential=credentials, logging_enable=True)
       return client
   
   try:
       client_catalog = get_catalog_client()
   except ValueError as e:
       print(e)  
   

3. Konfigurieren Sie Ihre Suchkriterien und Schlüsselwörter im Eingabetext:

   keywords = "keywords you want to search"
   
   body_input={
       "keywords": keywords
   }
   

   Hier geben Sie nur Schlüsselwörter an, aber denken Sie daran, dass Sie viele weitere Felder hinzufügen können, um Ihre Abfrage weiter anzugeben.

4. Durchsuchen Sie den Katalog:

   try:
       response = client_catalog.discovery.query(search_request=body_input)
       print(response)
   except HttpResponseError as e:
       print(e)
   

Vollständiger Code

from azure.purview.catalog import PurviewCatalogClient
from azure.identity import ClientSecretCredential 
from azure.core.exceptions import HttpResponseError

client_id = "<your client id>" 
client_secret = "<your client secret>"
tenant_id = "<your tenant id>"
reference_name_purview = "<name of your Microsoft Purview account>"
keywords = "<keywords you want to search for>"

def get_credentials():
	credentials = ClientSecretCredential(client_id=client_id, client_secret=client_secret, tenant_id=tenant_id)
	return credentials

def get_catalog_client():
	credentials = get_credentials()
	client = PurviewCatalogClient(endpoint=purview_endpoint, credential=credentials, logging_enable=True)
	return client

body_input={
	"keywords": keywords
}

try:
	catalog_client = get_catalog_client()
except ValueError as e:
	print(e)

try:
	response = catalog_client.discovery.query(search_request=body_input)
	print(response)
except HttpResponseError as e:
	print(e)

Löschen einer Datenquelle

In diesem Abschnitt erfahren Sie, wie Sie die zuvor registrierte Datenquelle löschen. Dieser Vorgang ist relativ einfach und erfolgt mit dem Scanclient.

1. Importieren Sie den Überprüfungsclient . Schließen Sie auch den HTTPResponse-Fehler und ClientSecretCredential ein.

   from azure.purview.scanning import PurviewScanningClient
   from azure.identity import ClientSecretCredential 
   from azure.core.exceptions import HttpResponseError
   

2. Erstellen Sie eine Funktion, um die Anmeldeinformationen für den Zugriff auf Ihr Microsoft Purview-Konto abzurufen, und instanziieren Sie den Überprüfungsclient.

   client_id = "<your client id>" 
   client_secret = "<your client secret>"
   tenant_id = "<your tenant id>"
   reference_name_purview = "<name of your Microsoft Purview account>"
   
   def get_credentials():
        credentials = ClientSecretCredential(client_id=client_id, client_secret=client_secret, tenant_id=tenant_id)
        return credentials
   
   def get_scanning_client():
       credentials = get_credentials()
       PurviewScanningClient(endpoint=f"https://{reference_name_purview}.scan.purview.azure.com", credential=credentials, logging_enable=True) 
       return client
   
   try:
       client_scanning = get_scanning_client()
   except ValueError as e:
       print(e)  
   

3. Löschen Sie die Datenquelle:

       ds_name = "<name of the registered data source you want to delete>"
       try:
           response = client_scanning.data_sources.delete(ds_name)
           print(response)
           print(f"Data source {ds_name} successfully deleted")
       except HttpResponseError as e:
           print(e)
   

Vollständiger Code

from azure.purview.scanning import PurviewScanningClient
from azure.identity import ClientSecretCredential 
from azure.core.exceptions import HttpResponseError


client_id = "<your client id>" 
client_secret = "<your client secret>"
tenant_id = "<your tenant id>"
reference_name_purview = "<name of your Microsoft Purview account>"
ds_name = "<name of the registered data source you want to delete>"

def get_credentials():
	credentials = ClientSecretCredential(client_id=client_id, client_secret=client_secret, tenant_id=tenant_id)
	return credentials

def get_scanning_client():
	credentials = get_credentials()
	client = PurviewScanningClient(endpoint=f"https://{reference_name_purview}.scan.purview.azure.com", credential=credentials, logging_enable=True) 
	return client

try:
	client_scanning = get_scanning_client()
except ValueError as e:
	print(e)  

try:
	response = client_scanning.data_sources.delete(ds_name)
	print(response)
	print(f"Data source {ds_name} successfully deleted")
except HttpResponseError as e:
	print(e)

Nächste Schritte