Início Rápido: Partilhar dados com o SDK .NET

Artigo
11/20/2024

Importante

Esta funcionalidade está atualmente a ser descontinuada, com suporte fornecido até setembro de 2025 para permitir a migração para a partilha de dados externos do Microsoft Fabric.

Neste início rápido, irá utilizar o SDK .NET para partilhar dados e receber partilhas de Azure Data Lake Storage (ADLS Gen2) ou contas de armazenamento de Blobs. O artigo inclui fragmentos de código que lhe permitem criar, aceitar e gerir partilhas com Compartilhamento de Dados do Microsoft Purview.

Para obter uma descrição geral de como funciona a partilha de dados, watch esta breve demonstração.

Observação

Esta funcionalidade foi atualizada em fevereiro de 2023 e o SDK e as permissões necessárias para ver e gerir partilhas de dados no Microsoft Purview mudaram.

Não são agora necessárias permissões no Microsoft Purview para utilizar o SDK para criar e gerir partilhas. (São necessárias permissões de leitor para utilizar o Portal de Governação do Microsoft Purview para partilhar dados.)
As permissões continuam a ser necessárias nas contas de armazenamento.

Veja o pacote NuGet atualizado e os fragmentos de código atualizados para utilizar o SDK atualizado.

Pré-requisitos

Pré-requisitos do Microsoft Purview

Uma conta do Microsoft Purview. Também pode utilizar duas contas do Microsoft Purview, uma para o fornecedor de dados e outra para o consumidor de dados testar ambos os cenários.
O endereço de e-mail de início de sessão do Azure do destinatário que pode utilizar para enviar o convite. O alias de e-mail do destinatário não funcionará.

Pré-requisitos da conta de Armazenamento do Azure

A sua subscrição do Azure tem de estar registada para a funcionalidade de pré-visualização AllowDataSharing . (Se ainda não registou esta funcionalidade de pré-visualização, considere utilizar a partilha de dados externos do Microsoft Fabric, uma vez que Compartilhamento de Dados do Microsoft Purview será descontinuada em setembro de 2025.) Em alternativa, contacte o suporte.
Contas de armazenamento de origem e de destino criadas após a conclusão do passo de registo. Ambas as contas de armazenamento têm de estar na mesma região do Azure que as outras. Ambas as contas de armazenamento têm de ser contas do ADLS Gen2 ou do Armazenamento de Blobs. As suas contas de armazenamento podem estar numa região do Azure diferente da sua conta do Microsoft Purview.
Versão mais recente do SDK de armazenamento, PowerShell, CLI e Gerenciador de Armazenamento do Azure. A versão da API REST de Armazenamento tem de ser fevereiro de 2020 ou posterior.
As contas de armazenamento têm de estar registadas nas coleções para onde irá enviar ou receber a partilha. Se estiver a utilizar uma conta do Microsoft Purview, estas podem ser duas coleções diferentes ou a mesma coleção. Para obter instruções para se registar, veja as páginas de origem de dados do Armazenamento de blobs ou do ADLS Gen2.
Se as contas de armazenamento de origem ou de destino estiverem numa subscrição do Azure diferente da da conta do Microsoft Purview, a Microsoft. O fornecedor de recursos do Purview é registado automaticamente na subscrição do Azure onde o arquivo de dados está localizado no momento em que o fornecedor de partilha adiciona um recurso ou partilha o mapeamento de um recurso e APENAS se o utilizador tiver permissão para efetuar a operação /register/action para o fornecedor de recursos. A permissão está incluída nas funções Contribuidor e Proprietário.

Observação

Este registo só é necessário da primeira vez ao partilhar ou receber dados numa conta de armazenamento na subscrição do Azure.

Funções necessárias

Eis as funções necessárias para partilhar dados e receber partilhas.

	Funções da conta de Armazenamento do Azure	Funções de coleção do Microsoft Purview
Fornecedor de dados	Uma das seguintes funções: Proprietário Proprietário de Dados do Blob de Armazenamento	Leitor de Dados
Consumidor de dados	Uma das seguintes funções: Colaborador Proprietário Contribuidor de Dados do Blob de Armazenamento Proprietário de Dados do Blob de Armazenamento	Leitor de Dados

Observação

Se tiver criado a conta do Microsoft Purview, ser-lhe-ão atribuídas automaticamente todas as funções à coleção de raiz. Consulte permissões do Microsoft Purview para saber mais sobre a coleção e funções do Microsoft Purview.

Visual Studio

As instruções neste artigo utilizam o Visual Studio 2022. Os procedimentos para Visual Studio 2013, 2015, 2017 ou 2019 podem diferir ligeiramente.

Azure .NET SDK

Transfira e instale o SDK .NET do Azure no seu computador.

Utilizar um principal de serviço

Nos fragmentos de código neste tutorial, pode autenticar com as suas próprias credenciais ou com um principal de serviço. Para configurar um principal de serviço, siga estas instruções:

Em Criar uma aplicação Microsoft Entra, crie uma aplicação que represente a aplicação .NET que está a criar neste tutorial. Para o URL de início de sessão, pode fornecer um URL fictício, conforme mostrado no artigo (https://contoso.org/exampleapp).
Em Obter valores para iniciar sessão, obtenha o ID da aplicação, o ID do inquilino e o ID do objeto e anote estes valores que irá utilizar mais à frente neste tutorial.
Em Certificados e segredos, obtenha a chave de autenticação e anote este valor que irá utilizar mais à frente neste tutorial.

atribua a aplicação a estas funções:

Usuário	Funções da conta de Armazenamento do Azure	Funções de coleção do Microsoft Purview
Fornecedor de dados	Uma das seguintes funções: Proprietário Proprietário de Dados do Armazenamento de Blobs	Contribuidor do Data Share
Consumidor de dados	Uma das seguintes funções: Colaborador Proprietário Contribuidor de Dados do Blob de Armazenamento Proprietário de Dados do Armazenamento de Blobs	Contribuidor do Data Share

Criar um projeto do Visual Studio

Em seguida, crie uma aplicação de consola .NET C# no Visual Studio:

Inicie o Visual Studio.
Na janela Iniciar, selecione Criar um novo projeto>Aplicação de Consola. É necessária a versão 6.0 ou superior do .NET.
Em Nome do projeto, introduza PurviewDataSharingQuickStart.
Selecione Criar para criar o projeto.

Instalar pacotes NuGet

Selecione Ferramentas>Consola do Gestor de Pacotes do Gestor > dePacotes NuGet.
Na Consola de Gestão de Pacotes , execute o comando .NET cli add package apresentado nesta página para adicionar o pacote NuGet: pacote NuGet: Microsoft.Azure.Analytics.Purview.Sharing NuGet.
No painel Consola do Gestor de Pacotes , execute os seguintes comandos para instalar pacotes.
```
Install-Package Azure.Analytics.Purview.Sharing -IncludePrerelease
Install-Package Azure.Identity
```
Dica

Se receber um erro que indica "Não foi possível localizar nenhum projeto em..." Ao tentar estes comandos, poderá ter apenas de mover um nível de pasta para baixo no seu projeto. Experimente o comando dir para listar pastas no seu diretório e, em seguida, utilize "nome cd <da pasta> do projeto" para mover um nível para baixo para a pasta do projeto. Em seguida, tente novamente.

Este script cria uma partilha de dados que pode enviar a utilizadores internos ou externos. Para utilizá-lo, certifique-se de que preenche estas variáveis:

SenderTenantId – o ID do Inquilino do Azure para a identidade do remetente.
SenderPurviewAccountName – o nome da conta do Microsoft Purview a partir da qual os dados serão enviados.
ShareName – um nome a apresentar para a partilha enviada.
ShareDescription – (opcional) Uma descrição para a partilha enviada.
SenderStorageKind - BlobAccount ou AdlsGen2Account.
SenderStorageResourceId - o ID de recurso da conta de armazenamento a partir da qual os dados serão enviados.
SenderStorageContainer – o nome do contentor onde os dados a partilhar são armazenados.
SenderPathToShare - o caminho de ficheiro/pasta para os dados a serem partilhados.
UseServiceTokenCredentials – (opcional) Se quiser utilizar um principal de serviço para criar as partilhas, defina-o como verdadeiro.
SenderClientId - (opcional) Se utilizar um principal de serviço para criar as partilhas, este é o ID da Aplicação (cliente) do principal de serviço.
SenderClientSecret – (opcional) Se utilizar um principal de serviço para criar as partilhas, adicione a chave de autenticação/segredo do cliente.
SentShareID – (opcional) Esta opção tem de ser um GUID e o valor atual gera um automaticamente, mas pode substituí-lo por um valor diferente, se quiser.
ReceiverVisiblePath – (opcional) O nome da partilha que o recetor irá ver. Atualmente definido como um GUID, mas o GUID não é necessário.
SenderPurviewEndPoint - Se estiver a utilizar a experiência clássica do Microsoft Purview, utilize $"https://{SenderPurviewAccountName}.purview.azure.com"; Se estiver a utilizar a nova experiência do Microsoft Purview, utilize https://api.purview-service.microsoft.com/

using Azure;
using Azure.Analytics.Purview.Sharing;
using Azure.Core;
using Azure.Identity;
using System.ComponentModel;

public static class PurviewDataSharingQuickStart
{
    // [REQUIRED INPUTS] Set To Actual Values.
    private static string SenderTenantId = "<Sender Identity's Tenant ID>";
    private static string SenderPurviewAccountName = "<Sender Purview Account Name>";

    private static string ShareName = "<Share Display Name>";
    private static string ShareDescription = "Share created using the SDK.";
    private static string SenderStorageKind = "<Sender Storage Account Kind (BlobAccount / AdlsGen2Account)>";
    private static string SenderStorageResourceId = "<Sender Storage Account Resource Id>";
    private static string SenderStorageContainer = "<Share Data Container Name>";
    private static string SenderPathToShare = "<File/Folder Path To Share>";

    // Set if using Service principal to create shares
    private static bool UseServiceTokenCredentials = false;
    private static string SenderClientId = "<Sender Application (Client) Id>";
    private static string SenderClientSecret = "<Sender Application (Client) Secret>";

    // [OPTIONAL INPUTS] Override Value If Desired.
    private static string SentShareId = Guid.NewGuid().ToString();
    private static string ReceiverVisiblePath = Guid.NewGuid().ToString();

    // General Configs
    private static string SenderPurviewEndPoint = $"https://{SenderPurviewAccountName}.purview.azure.com";
    private static string SenderShareEndPoint = $"{SenderPurviewEndPoint}/share";

    private static async Task Main(string[] args)
    {
        try
        {
            /// Replace all placeholder inputs above with actual values before running this program.
            /// This updated Share experience API will create Shares based on callers RBAC role on the storage account.
            /// To view/manage Shares via UX in Purview Studio. Storage accounts need to be registered (one time action) in Purview account with DSA permissions.

            Console.WriteLine($"{DateTime.Now.ToShortTimeString()}: CreateShare - START");
            await Sender_CreateSentShare();
            Console.WriteLine($"{DateTime.Now.ToShortTimeString()}: CreateShare - FINISH");
        }
        catch (Exception ex)
        {
            Console.ForegroundColor = ConsoleColor.Red;
            Console.WriteLine(ex);
            Console.ForegroundColor = Console.ForegroundColor;
        }
    }

    private static async Task<BinaryData> Sender_CreateSentShare()
    {

        TokenCredential senderCredentials = UseServiceTokenCredentials
                ? new ClientSecretCredential(SenderTenantId, SenderClientId, SenderClientSecret)
                : new DefaultAzureCredential(new DefaultAzureCredentialOptions { AuthorityHost = new Uri("https://login.windows.net"), TenantId = SenderTenantId });

        SentSharesClient? sentSharesClient = new SentSharesClient(SenderShareEndPoint, senderCredentials);

        if (sentSharesClient == null)
        {
            throw new InvalidEnumArgumentException("Invalid Sent Shares Client.");
        }

        // Create sent share
        var inPlaceSentShareDto = new
        {
            shareKind = "InPlace",
            properties = new
            {
                displayName = ShareName,
                description = ShareDescription,
                artifact = new
                {
                    storeKind = SenderStorageKind,
                    storeReference = new
                    {
                        referenceName = SenderStorageResourceId,
                        type = "ArmResourceReference"
                    },
                    properties = new
                    {
                        paths = new[]
                        {
                            new
                            {
                                receiverPath = ReceiverVisiblePath,
                                containerName = SenderStorageContainer,
                                senderPath = SenderPathToShare
                            }
                        }
                    }
                }
            },
        };

        Operation<BinaryData> sentShare = await sentSharesClient.CreateOrReplaceSentShareAsync(WaitUntil.Completed, SentShareId, RequestContent.Create(inPlaceSentShareDto));
        Console.ForegroundColor = ConsoleColor.Green;
        Console.WriteLine(sentShare.Value);
        Console.ForegroundColor = Console.ForegroundColor;
        return sentShare.Value;
    }
}

Enviar convite a um utilizador

Este script envia um convite por e-mail para uma partilha a um utilizador. Se quiser enviar um convite para um principal de serviço, veja o exemplo de código seguinte. Para utilizá-lo, certifique-se de que preenche estas variáveis:

RecipientUserEmailId - Email endereço para o utilizador enviar o convite.
SenderTenantId – o ID do Inquilino do Azure para a identidade do remetente da partilha.
SenderPurviewAccountName – o nome da conta do Microsoft Purview a partir da qual os dados serão enviados.
SenderStorageResourceId - o ID de recurso da conta de armazenamento a partir da qual os dados serão enviados.
SentShareDisplayName – o nome da partilha enviada para a qual está a enviar um convite.
UseServiceTokenCredentials – (opcional) Se quiser utilizar um principal de serviço para criar as partilhas, defina-o como verdadeiro.
SenderClientId - (opcional) Se utilizar um principal de serviço para criar as partilhas, este é o ID da Aplicação (cliente) do principal de serviço.
SenderClientSecret – (opcional) Se utilizar um principal de serviço para criar as partilhas, adicione a chave de autenticação/segredo do cliente.
InvitationId – (opcional) Esta opção tem de ser um GUID e o valor atual gera um por si, mas pode substituí-lo por um valor diferente, se quiser.
SenderPurviewEndPoint - Se estiver a utilizar a experiência clássica do Microsoft Purview, utilize $"https://{SenderPurviewAccountName}.purview.azure.com"; Se estiver a utilizar a nova experiência do Microsoft Purview, utilize https://api.purview-service.microsoft.com/

using Azure;
using Azure.Analytics.Purview.Sharing;
using Azure.Core;
using Azure.Identity;
using System.ComponentModel;
using System.Text.Json;

public static class PurviewDataSharingQuickStart
{
    // [REQUIRED INPUTS] Set To Actual Values.
    private static string RecipientUserEmailId = "<Target User's Email Id>";

    private static string SenderTenantId = "<Sender Indentity's Tenant ID>";
    private static string SenderPurviewAccountName = "<Sender Purview Account Name>";
    private static string SenderStorageResourceId = "<Sender Storage Account Resource Id>";

    // Set if using Service principal to send invitation
    private static bool UseServiceTokenCredentials = false;
    private static string SenderClientId = "<Sender Application (Client) Id>";
    private static string SenderClientSecret = "<Sender Application (Client) Secret>";

    private static string SentShareDisplayName = "<Name of share you're sending an invite for.>";
    private static string InvitationId = Guid.NewGuid().ToString();

    // General Configs
    private static string SenderPurviewEndPoint = $"https://{SenderPurviewAccountName}.purview.azure.com";
    private static string SenderShareEndPoint = $"{SenderPurviewEndPoint}/share";
    private static int StepCounter = 0;

    private static async Task Main(string[] args)
    {
        try
        {

            Console.WriteLine($"{DateTime.Now.ToShortTimeString()}: SendtoUser - START");
            await Sender_CreateUserRecipient();
            Console.WriteLine($"{DateTime.Now.ToShortTimeString()}: SendtoUser - FINISH");
        }
        catch (Exception ex)
        {
            Console.ForegroundColor = ConsoleColor.Red;
            Console.WriteLine(ex);
            Console.ForegroundColor = Console.ForegroundColor;
        }
    }

    public static async Task<List<T>> ToResultList<T>(this AsyncPageable<T> asyncPageable)
    {
        List<T> list = new List<T>();

        await foreach (T item in asyncPageable)
        {
            list.Add(item);
        }

        return list;
    }

    private static async Task<BinaryData> Sender_CreateUserRecipient()
    {

        TokenCredential senderCredentials = UseServiceTokenCredentials
                ? new ClientSecretCredential(SenderTenantId, SenderClientId, SenderClientSecret)
                : new DefaultAzureCredential(new DefaultAzureCredentialOptions { AuthorityHost = new Uri("https://login.windows.net"), TenantId = SenderTenantId });

        SentSharesClient? sentSharesClient = new SentSharesClient(SenderShareEndPoint, senderCredentials);

        if (string.IsNullOrEmpty(RecipientUserEmailId))
        {
            throw new InvalidEnumArgumentException("Invalid Recipient User Email Id.");
        }

        // Create user recipient and invite
        var invitationData = new
        {
            invitationKind = "User",
            properties = new
            {
                expirationDate = DateTime.Now.AddDays(7).ToString(),
                notify = true, // Send invitation email
                targetEmail = RecipientUserEmailId
            }
        };

        var allSentShares = await sentSharesClient.GetAllSentSharesAsync(SenderStorageResourceId).ToResultList();

        Console.ForegroundColor = ConsoleColor.Yellow;
        Console.WriteLine("{0}. {1}...", ++StepCounter, "Get a Specific Sent Share");
        Console.ForegroundColor = Console.ForegroundColor;

        var mySentShare = allSentShares.First(sentShareDoc =>
        {
            var doc = JsonDocument.Parse(sentShareDoc).RootElement;
            var props = doc.GetProperty("properties");
            return props.GetProperty("displayName").ToString() == SentShareDisplayName;
        });

        Console.ForegroundColor = ConsoleColor.Green;
        Console.WriteLine("My Sent Share Id: " + JsonDocument.Parse(mySentShare).RootElement.GetProperty("id").ToString());
        Console.ForegroundColor = Console.ForegroundColor;

        var SentShareId = JsonDocument.Parse(mySentShare).RootElement.GetProperty("id").ToString();

        var sentInvitation = await sentSharesClient.CreateSentShareInvitationAsync(SentShareId, InvitationId, RequestContent.Create(invitationData));

        Console.ForegroundColor = ConsoleColor.Green;
        Console.WriteLine(sentInvitation.Content);
        Console.ForegroundColor = Console.ForegroundColor;

        return sentInvitation.Content;
    }
}

Enviar convite para um serviço

Este script envia um convite por e-mail para uma partilha para um principal de serviço. Se quiser enviar um convite a um utilizador, veja o exemplo anterior. Para utilizá-lo, certifique-se de que preenche estas variáveis:

RecipientApplicationTenantId – o ID de Inquilino do Azure para o principal de serviço de receção.
RecipientApplicationObjectId - o ID de objeto do principal de serviço de receção.
SenderTenantId – o ID do Inquilino do Azure para a identidade do remetente da partilha.
SenderPurviewAccountName – o nome da conta do Microsoft Purview a partir da qual os dados serão enviados.
SenderStorageResourceId - o ID de recurso da conta de armazenamento a partir da qual os dados serão enviados.
SentShareDisplayName – o nome da partilha enviada para a qual está a enviar um convite.
UseServiceTokenCredentials – (opcional) Se quiser utilizar um principal de serviço para criar as partilhas, defina-o como verdadeiro.
SenderClientId - (opcional) Se utilizar um principal de serviço para criar as partilhas, este é o ID da Aplicação (cliente) do principal de serviço.
SenderClientSecret – (opcional) Se utilizar um principal de serviço para criar as partilhas, adicione a chave de autenticação/segredo do cliente.
InvitationId – (opcional) Esta opção tem de ser um GUID e o valor atual gera um por si, mas pode substituí-lo por um valor diferente, se quiser.
SenderPurviewEndPoint - Se estiver a utilizar a experiência clássica do Microsoft Purview, utilize $"https://{SenderPurviewAccountName}.purview.azure.com"; Se estiver a utilizar a nova experiência do Microsoft Purview, utilize https://api.purview-service.microsoft.com/

using Azure;
using Azure.Analytics.Purview.Sharing;
using Azure.Core;
using Azure.Identity;
using System.ComponentModel;
using System.Text.Json;

public static class PurviewDataSharingQuickStart
{
    // [REQUIRED INPUTS] Set To Actual Values.
    private static string RecipientApplicationTenantId = "<Target Application's Tenant Id>";
    private static string RecipientApplicationObjectId = "<Target Application's Object Id>";

    private static string SentShareDisplayName = "<Name of share you're sending an invite for.>";
    private static string InvitationId = Guid.NewGuid().ToString();

    private static string SenderTenantId = "<Sender Indentity's Tenant ID>";
    private static string SenderPurviewAccountName = "<Sender Purview Account Name>";

    private static string SenderStorageResourceId = "<Resource ID for storage account that has been shared>";

    // Set if using Service principal to send invitation
    private static bool UseServiceTokenCredentials = false;
    private static string SenderClientId = "<Sender Application (Client) Id>";
    private static string SenderClientSecret = "<Sender Application (Client) Secret>";

    // General Configs
    private static string SenderPurviewEndPoint = $"https://{SenderPurviewAccountName}.purview.azure.com";
    private static string SenderShareEndPoint = $"{SenderPurviewEndPoint}/share";

    private static async Task Main(string[] args)
    {
        try
        {

            Console.WriteLine($"{DateTime.Now.ToShortTimeString()}: SendtoService - START");
            await Sender_CreateServiceRecipient();
            Console.WriteLine($"{DateTime.Now.ToShortTimeString()}: SendtoService - FINISH");
        }
        catch (Exception ex)
        {
            Console.ForegroundColor = ConsoleColor.Red;
            Console.WriteLine(ex);
            Console.ForegroundColor = Console.ForegroundColor;
        }
    }

    public static async Task<List<T>> ToResultList<T>(this AsyncPageable<T> asyncPageable)
    {
        List<T> list = new List<T>();

        await foreach (T item in asyncPageable)
        {
            list.Add(item);
        }

        return list;
    }

    private static async Task<BinaryData> Sender_CreateServiceRecipient()
    {

        TokenCredential senderCredentials = UseServiceTokenCredentials
                ? new ClientSecretCredential(SenderTenantId, SenderClientId, SenderClientSecret)
                : new DefaultAzureCredential(new DefaultAzureCredentialOptions { AuthorityHost = new Uri("https://login.windows.net"), TenantId = SenderTenantId });

        SentSharesClient? sentSharesClient = new SentSharesClient(SenderShareEndPoint, senderCredentials);

        if (!Guid.TryParse(RecipientApplicationTenantId, out Guid _))
        {
            throw new InvalidEnumArgumentException("Invalid Recipient Service Tenant Id.");
        }

        if (!Guid.TryParse(RecipientApplicationObjectId, out Guid _))
        {
            throw new InvalidEnumArgumentException("Invalid Recipient Service Object Id.");
        }

        // Create service recipient
        var invitationData = new
        {
            invitationKind = "Service",
            properties = new
            {
                expirationDate = DateTime.Now.AddDays(5).ToString(),
                targetActiveDirectoryId = RecipientApplicationTenantId,
                targetObjectId = RecipientApplicationObjectId
            }
        };


        var allSentShares = await sentSharesClient.GetAllSentSharesAsync(SenderStorageResourceId).ToResultList();
        var mySentShare = allSentShares.First(sentShareDoc =>
        {
            var doc = JsonDocument.Parse(sentShareDoc).RootElement;
            var props = doc.GetProperty("properties");
            return props.GetProperty("displayName").ToString() == SentShareDisplayName;
        });

        var SentShareId = JsonDocument.Parse(mySentShare).RootElement.GetProperty("id").ToString();

        var sentInvitation = await sentSharesClient.CreateSentShareInvitationAsync(SentShareId, InvitationId, RequestContent.Create(invitationData));
        Console.ForegroundColor = ConsoleColor.Green;
        Console.WriteLine(sentInvitation.Content);
        Console.ForegroundColor = Console.ForegroundColor;
        return sentInvitation.Content;
    }

}

Listar partilhas enviadas

Este script lista todas as partilhas enviadas para um recurso de armazenamento específico. Para utilizá-lo, certifique-se de que preenche estas variáveis:

SenderTenantId – o ID do Inquilino do Azure para a identidade do remetente da partilha.
SenderPurviewAccountName – o nome da conta do Microsoft Purview a partir da qual os dados foram enviados.
SenderStorageResourceId - o ID de recurso da conta de armazenamento a partir da qual foram enviadas as partilhas.
UseServiceTokenCredentials – (opcional) Se quiser utilizar um principal de serviço para criar as partilhas, defina-o como verdadeiro.
SenderClientId - (opcional) Se utilizar um principal de serviço para criar as partilhas, este é o ID da Aplicação (cliente) do principal de serviço.
SenderClientSecret – (opcional) Se utilizar um principal de serviço para criar as partilhas, adicione a chave de autenticação/segredo do cliente.
SenderPurviewEndPoint - Se estiver a utilizar a experiência clássica do Microsoft Purview, utilize $"https://{SenderPurviewAccountName}.purview.azure.com"; Se estiver a utilizar a nova experiência do Microsoft Purview, utilize https://api.purview-service.microsoft.com/

using Azure;
using Azure.Analytics.Purview.Sharing;
using Azure.Core;
using Azure.Identity;

public static class PurviewDataSharingQuickStart
{
    // [REQUIRED INPUTS] Set To Actual Values.
    private static string SenderTenantId = "<Sender Tenant ID>";
    private static string SenderPurviewAccountName = "<Name of the Microsoft Purview account>";
    private static string SenderStorageResourceId = "<Sender Storage Account Resource Id>";

    // Set if using Service principal to list shares
    private static bool UseServiceTokenCredentials = false;
    private static string SenderClientId = "<Sender Application (Client) Id>";
    private static string SenderClientSecret = "<Sender Application (Client) Secret>";

    // General Configs
    private static string SenderPurviewEndPoint = $"https://{SenderPurviewAccountName}.purview.azure.com";
    private static string SenderShareEndPoint = $"{SenderPurviewEndPoint}/share";

    private static async Task Main(string[] args)
    {


        try
        {
            TokenCredential senderCredentials = UseServiceTokenCredentials
                ? new ClientSecretCredential(SenderTenantId, SenderClientId, SenderClientSecret)
                : new DefaultAzureCredential(new DefaultAzureCredentialOptions { AuthorityHost = new Uri("https://login.windows.net"), TenantId = SenderTenantId });

            SentSharesClient? sentSharesClient = new SentSharesClient(SenderShareEndPoint, senderCredentials);

            var allSentShares = await sentSharesClient.GetAllSentSharesAsync(SenderStorageResourceId).ToResultList();
            Console.WriteLine(allSentShares);
        }
        catch (Exception ex)
        {
            Console.ForegroundColor = ConsoleColor.Red;
            Console.WriteLine(ex);
            Console.ForegroundColor = Console.ForegroundColor;
        }
    }

    public static async Task<List<T>> ToResultList<T>(this AsyncPageable<T> asyncPageable)
    {
        List<T> list = new List<T>();

        await foreach (T item in asyncPageable)
        {
            list.Add(item);
        }

        return list;
    }
}

Este script lista todos os destinatários de uma partilha específica. Para utilizá-lo, certifique-se de que preenche estas variáveis:

SenderTenantId – o ID do Inquilino do Azure para a identidade do remetente da partilha.
SenderPurviewAccountName – o nome da conta do Microsoft Purview a partir da qual os dados foram enviados.
SentShareDisplayName – o nome da partilha enviada para a qual está a listar destinatários.
SenderStorageResourceId - o ID de recurso da conta de armazenamento a partir da qual os dados serão enviados.
UseServiceTokenCredentials – (opcional) Se quiser utilizar um principal de serviço para criar as partilhas, defina-o como verdadeiro.
SenderClientId - (opcional) Se utilizar um principal de serviço para criar as partilhas, este é o ID da Aplicação (cliente) do principal de serviço.
SenderClientSecret – (opcional) Se utilizar um principal de serviço para criar as partilhas, adicione a chave de autenticação/segredo do cliente.
SenderPurviewEndPoint - Se estiver a utilizar a experiência clássica do Microsoft Purview, utilize $"https://{SenderPurviewAccountName}.purview.azure.com"; Se estiver a utilizar a nova experiência do Microsoft Purview, utilize https://api.purview-service.microsoft.com/

using Azure;
using Azure.Analytics.Purview.Sharing;
using Azure.Core;
using Azure.Identity;
using System.Text.Json;

public static class PurviewDataSharingQuickStart
{
    // [REQUIRED INPUTS] Set To Actual Values.
    private static string SentShareDisplayName = "<Name of share you're listing recipients for.>";
    private static string SenderTenantId = "<Sender Tenant ID>";
    private static string SenderPurviewAccountName = "<Name of the Microsoft Purview account>";

    private static string SenderStorageResourceId = "<Sender Storage Account Resource Id>";

    // Set if using Service principal to list recipients
    private static bool UseServiceTokenCredentials = false;
    private static string SenderClientId = "<Sender Application (Client) Id>";
    private static string SenderClientSecret = "<Sender Application (Client) Secret>";

    // General Configs
    private static string SenderPurviewEndPoint = $"https://{SenderPurviewAccountName}.purview.azure.com";
    private static string SenderShareEndPoint = $"{SenderPurviewEndPoint}/share";

    private static async Task Main(string[] args)
    {
        try
        {
            TokenCredential senderCredentials = UseServiceTokenCredentials
                ? new ClientSecretCredential(SenderTenantId, SenderClientId, SenderClientSecret)
                : new DefaultAzureCredential(new DefaultAzureCredentialOptions { AuthorityHost = new Uri("https://login.windows.net"), TenantId = SenderTenantId });

            SentSharesClient? sentSharesClient = new SentSharesClient(SenderShareEndPoint, senderCredentials);

            var allSentShares = await sentSharesClient.GetAllSentSharesAsync(SenderStorageResourceId).ToResultList();
            var mySentShare = allSentShares.First(sentShareDoc =>
            {
                var doc = JsonDocument.Parse(sentShareDoc).RootElement;
                var props = doc.GetProperty("properties");
                return props.GetProperty("displayName").ToString() == SentShareDisplayName;
            });

            Console.ForegroundColor = ConsoleColor.Green;
            Console.WriteLine("My Sent Share Id: " + JsonDocument.Parse(mySentShare).RootElement.GetProperty("id").ToString());
            Console.ForegroundColor = Console.ForegroundColor;

            var SentShareId = JsonDocument.Parse(mySentShare).RootElement.GetProperty("id").ToString();

            var allRecipients = await sentSharesClient.GetAllSentShareInvitationsAsync(SentShareId).ToResultList();
            Console.WriteLine(allRecipients);

        }
        catch (Exception ex)
        {
            Console.ForegroundColor = ConsoleColor.Red;
            Console.WriteLine(ex);
            Console.ForegroundColor = Console.ForegroundColor;
        }
    }

    public static async Task<List<T>> ToResultList<T>(this AsyncPageable<T> asyncPageable)
    {
        List<T> list = new List<T>();

        await foreach (T item in asyncPageable)
        {
            list.Add(item);
        }

        return list;
    }
}

Eliminar destinatário

Este script remove um convite de partilha e, por conseguinte, a partilha para um destinatário. Para utilizá-lo, certifique-se de que preenche estas variáveis:

SenderTenantId – o ID do Inquilino do Azure para a identidade do remetente da partilha.
SenderPurviewAccountName – o nome da conta do Microsoft Purview a partir da qual os dados foram enviados.
SentShareDisplayName – o nome da partilha enviada para a qual está a remover um destinatário.
SenderStorageResourceId - o ID de recurso da conta de armazenamento a partir da qual os dados serão enviados.
RecipientUserEmailId - Email endereço do utilizador que pretende eliminar.
UseServiceTokenCredentials – (opcional) Se quiser utilizar um principal de serviço para criar as partilhas, defina-o como verdadeiro.
SenderClientId - (opcional) Se utilizar um principal de serviço para criar as partilhas, este é o ID da Aplicação (cliente) do principal de serviço.
SenderClientSecret – (opcional) Se utilizar um principal de serviço para criar as partilhas, adicione a chave de autenticação/segredo do cliente.
SenderPurviewEndPoint - Se estiver a utilizar a experiência clássica do Microsoft Purview, utilize $"https://{SenderPurviewAccountName}.purview.azure.com"; Se estiver a utilizar a nova experiência do Microsoft Purview, utilize https://api.purview-service.microsoft.com/

using Azure;
using Azure.Analytics.Purview.Sharing;
using Azure.Core;
using Azure.Identity;
using System.Text.Json;

public static class PurviewDataSharingQuickStart
{
    // [REQUIRED INPUTS] Set To Actual Values.
    private static string SentShareDisplayName = "<Name of share you're removing a recipient for.>";
    private static string SenderTenantId = "<Sender Tenant ID>";
    private static string SenderPurviewAccountName = "<Name of the Microsoft Purview account>";
    private static string RecipientUserEmailId = "<Target User's Email Id>";

    private static string SenderStorageResourceId = "<Sender Storage Account Resource Id>";

    // Set if using Service principal to delete recipients
    private static bool UseServiceTokenCredentials = false;
    private static string SenderClientId = "<Sender Application (Client) Id>";
    private static string SenderClientSecret = "<Sender Application (Client) Secret>";

    // General Configs
    private static string SenderPurviewEndPoint = $"https://{SenderPurviewAccountName}.purview.azure.com";
    private static string SenderShareEndPoint = $"{SenderPurviewEndPoint}/share";

    private static async Task Main(string[] args)
    {
        try
        {
            TokenCredential senderCredentials = UseServiceTokenCredentials
                ? new ClientSecretCredential(SenderTenantId, SenderClientId, SenderClientSecret)
                : new DefaultAzureCredential(new DefaultAzureCredentialOptions { AuthorityHost = new Uri("https://login.windows.net"), TenantId = SenderTenantId });

            SentSharesClient? sentSharesClient = new SentSharesClient(SenderShareEndPoint, senderCredentials);

            var allSentShares = await sentSharesClient.GetAllSentSharesAsync(SenderStorageResourceId).ToResultList();

            var mySentShare = allSentShares.First(sentShareDoc =>
            {
                var doc = JsonDocument.Parse(sentShareDoc).RootElement;
                var props = doc.GetProperty("properties");
                return props.GetProperty("displayName").ToString() == SentShareDisplayName;
            });

            var SentShareId = JsonDocument.Parse(mySentShare).RootElement.GetProperty("id").ToString();

            var allRecipients = await sentSharesClient.GetAllSentShareInvitationsAsync(SentShareId).ToResultList();

            var recipient = allRecipients.First(recipient =>
            {
                var doc = JsonDocument.Parse(recipient).RootElement;
                var props = doc.GetProperty("properties");
                return props.TryGetProperty("targetEmail", out JsonElement rcpt) && rcpt.ToString() == RecipientUserEmailId;
            });

            var recipientId = JsonDocument.Parse(recipient).RootElement.GetProperty("id").ToString();

            await sentSharesClient.DeleteSentShareInvitationAsync(WaitUntil.Completed, SentShareId, recipientId);

            Console.ForegroundColor = ConsoleColor.Green;
            Console.WriteLine("Remove Id: " + JsonDocument.Parse(recipient).RootElement.GetProperty("id").ToString());
            Console.WriteLine("Complete");
            Console.ForegroundColor = Console.ForegroundColor;

        }

        catch (Exception ex)
        {
            Console.ForegroundColor = ConsoleColor.Red;
            Console.WriteLine(ex);
            Console.ForegroundColor = Console.ForegroundColor;
        }
    }

    public static async Task<List<T>> ToResultList<T>(this AsyncPageable<T> asyncPageable)
    {
        List<T> list = new List<T>();

        await foreach (T item in asyncPageable)
        {
            list.Add(item);
        }

        return list;
    }
}

Este script elimina uma partilha enviada. Para utilizá-lo, certifique-se de que preenche estas variáveis:

SenderTenantId – o ID do Inquilino do Azure para a identidade do remetente da partilha.
SenderPurviewAccountName – o nome da conta do Microsoft Purview a partir da qual os dados foram enviados.
SentShareDisplayName – o nome da partilha enviada para a qual está a listar destinatários.
SenderStorageResourceId - o ID de recurso da conta de armazenamento a partir da qual os dados serão enviados.
UseServiceTokenCredentials – (opcional) Se quiser utilizar um principal de serviço para criar as partilhas, defina-o como verdadeiro.
SenderClientId - (opcional) Se utilizar um principal de serviço para criar as partilhas, este é o ID da Aplicação (cliente) do principal de serviço.
SenderClientSecret – (opcional) Se utilizar um principal de serviço para criar as partilhas, adicione a chave de autenticação/segredo do cliente.
SenderPurviewEndPoint - Se estiver a utilizar a experiência clássica do Microsoft Purview, utilize $"https://{SenderPurviewAccountName}.purview.azure.com"; Se estiver a utilizar a nova experiência do Microsoft Purview, utilize https://api.purview-service.microsoft.com/

using Azure;
using Azure.Analytics.Purview.Sharing;
using Azure.Core;
using Azure.Identity;
using System.Text.Json;

public static class PurviewDataSharingQuickStart
{
    // [REQUIRED INPUTS] Set To Actual Values.
    private static string SenderTenantId = "<Sender Tenant ID>";
    private static string SenderPurviewAccountName = "<Name of the Microsoft Purview account>";
    private static string SentShareDisplayName = "<Name of share you're removing.>";

    private static string SenderStorageResourceId = "<Sender Storage Account Resource Id>";

    // Set if using Service principal to delete share
    private static bool UseServiceTokenCredentials = false;
    private static string SenderClientId = "<Sender Application (Client) Id>";
    private static string SenderClientSecret = "<Sender Application (Client) Secret>";

    // General Configs
    private static string SenderPurviewEndPoint = $"https://{SenderPurviewAccountName}.purview.azure.com";
    private static string SenderShareEndPoint = $"{SenderPurviewEndPoint}/share";

    private static async Task Main(string[] args)
    {
        try
        {
            TokenCredential senderCredentials = UseServiceTokenCredentials
                ? new ClientSecretCredential(SenderTenantId, SenderClientId, SenderClientSecret)
                : new DefaultAzureCredential(new DefaultAzureCredentialOptions { AuthorityHost = new Uri("https://login.windows.net"), TenantId = SenderTenantId });

            SentSharesClient? sentSharesClient = new SentSharesClient(SenderShareEndPoint, senderCredentials);

            var allSentShares = await sentSharesClient.GetAllSentSharesAsync(SenderStorageResourceId).ToResultList();

            var mySentShare = allSentShares.First(sentShareDoc =>
            {
                var doc = JsonDocument.Parse(sentShareDoc).RootElement;
                var props = doc.GetProperty("properties");
                return props.GetProperty("displayName").ToString() == SentShareDisplayName;
            });

            var SentShareId = JsonDocument.Parse(mySentShare).RootElement.GetProperty("id").ToString();

            await sentSharesClient.DeleteSentShareAsync(WaitUntil.Completed, SentShareId);

            Console.ForegroundColor = ConsoleColor.Green;
            Console.WriteLine("Remove Id: " + SentShareId);
            Console.WriteLine("Complete");
            Console.ForegroundColor = Console.ForegroundColor;

        }
        catch (Exception ex)
        {
            Console.ForegroundColor = ConsoleColor.Red;
            Console.WriteLine(ex);
            Console.ForegroundColor = Console.ForegroundColor;
        }
    }

    public static async Task<List<T>> ToResultList<T>(this AsyncPageable<T> asyncPageable)
    {
        List<T> list = new List<T>();

        await foreach (T item in asyncPageable)
        {
            list.Add(item);
        }

        return list;
    }
}

Este script permite-lhe receber uma partilha de dados. Para utilizá-lo, certifique-se de que preenche estas variáveis:

ReceiverTenantId - o ID de Inquilino do Azure para o utilizador/serviço que está a receber os dados partilhados.
ReceiverPurviewAccountName – o nome da conta do Microsoft Purview onde os dados serão recebidos.
ReceiverStorageKind - BlobAccount ou AdlsGen2Account.
ReceiverStorageResourceId - o ID de recurso da conta de armazenamento onde os dados serão recebidos.
ReceiverStorageContainer – o nome do contentor onde os dados partilhados serão armazenados.
ReceiverTargetFolderName – o caminho da pasta para onde os dados partilhados serão armazenados.
ReceiverTargetMountPath - o caminho de montagem que pretende utilizar para armazenar os seus dados na pasta.
UseServiceTokenCredentials - (opcional) Se quiser utilizar um principal de serviço para receber as partilhas, defina-o como verdadeiro.
ReceiverClientId - (opcional) Se estiver a utilizar um principal de serviço para receber as partilhas, este é o ID da Aplicação (cliente) do principal de serviço.
ReceiverClientSecret - (opcional) Se estiver a utilizar um principal de serviço para receber as partilhas, adicione a chave de autenticação/segredo do cliente.
ReceivedShareId – (opcional) Esta opção tem de ser um GUID e o valor atual irá gerar um por si, mas pode substituí-lo por um valor diferente, se quiser.
ReceiverVisiblePath - (opcional) Nome que pretende utilizar para o caminho da partilha recebida.
ReceivedShareDisplayName – (opcional) Um nome a apresentar para a partilha recebida.
ReceiverPurviewEndPoint - Se estiver a utilizar a experiência clássica do Microsoft Purview, utilize $"https://{ReceiverPurviewAccountName}.purview.azure.com"; Se estiver a utilizar a nova experiência do Microsoft Purview, utilize https://api.purview-service.microsoft.com/

using Azure;
using Azure.Analytics.Purview.Sharing;
using Azure.Core;
using Azure.Identity;
using System.ComponentModel;
using System.Text.Json;

public static class PurviewDataSharingQuickStart
{
    // [REQUIRED INPUTS] Set To Actual Values.
    private static string ReceiverTenantId = "<Receiver Indentity's Tenant ID>";
    private static string ReceiverPurviewAccountName = "<Receiver Purview Account Name>";

    private static string ReceiverStorageKind = "<Receiver Storage Account Kind (BlobAccount / AdlsGen2Account)>";
    private static string ReceiverStorageResourceId = "<Receiver Storage Account Resource Id>";
    private static string ReceiverStorageContainer = "<Container Name To Receive Data Under>";
    private static string ReceiverTargetFolderName = "<Folder Name to Received Data Under>";
    private static string ReceiverTargetMountPath = "<Mount Path to store Received Data Under>";

    //Use if using a service principal to receive a share
    private static bool UseServiceTokenCredentials = false;
    private static string ReceiverClientId = "<Receiver Caller Application (Client) Id>";
    private static string ReceiverClientSecret = "<Receiver Caller Application (Client) Secret>";

    // [OPTIONAL INPUTS] Override Values If Desired.
    private static string ReceivedShareId = Guid.NewGuid().ToString();
    private static string ReceiverVisiblePath = "ReceivedSharePath";

    private static string ReceivedShareDisplayName = "ReceivedShare";

    // General Configs
    private static string ReceiverPurviewEndPoint = $"https://{ReceiverPurviewAccountName}.purview.azure.com";
    private static string ReceiverShareEndPoint = $"{ReceiverPurviewEndPoint}/share";

    private static async Task Main(string[] args)
    {
        try
        {


            Console.WriteLine($"{DateTime.Now.ToShortTimeString()}: CreateReceivedShare - START");
            await Receiver_CreateReceivedShare();
            Console.WriteLine($"{DateTime.Now.ToShortTimeString()}: CreateReceivedShare - FINISH");
        }
        catch (Exception ex)
        {
            Console.ForegroundColor = ConsoleColor.Red;
            Console.WriteLine(ex);
            Console.ForegroundColor = Console.ForegroundColor;
        }
    }

    private static async Task<BinaryData> Receiver_CreateReceivedShare()
    {

        TokenCredential receiverCredentials = UseServiceTokenCredentials
            ? new ClientSecretCredential(ReceiverTenantId, ReceiverClientId, ReceiverClientSecret)
            : new DefaultAzureCredential(new DefaultAzureCredentialOptions { AuthorityHost = new Uri("https://login.windows.net"), TenantId = ReceiverTenantId });

        ReceivedSharesClient? receivedSharesClient = new ReceivedSharesClient(ReceiverShareEndPoint, receiverCredentials);

        if (receivedSharesClient == null)
        {
            throw new InvalidEnumArgumentException("Invalid Received Shares Client.");
        }

        var results = await receivedSharesClient.GetAllDetachedReceivedSharesAsync().ToResultList();
        var detachedReceivedShare = results;

        if (detachedReceivedShare == null)
        {
            throw new InvalidOperationException("No received shares found.");
        }



        var myReceivedShare = detachedReceivedShare.First(recShareDoc =>
        {
            var doc = JsonDocument.Parse(recShareDoc).RootElement;
            var props = doc.GetProperty("properties");
            return props.GetProperty("displayName").ToString() == ReceivedShareDisplayName;
        });

        var ReceivedShareId = JsonDocument.Parse(myReceivedShare).RootElement.GetProperty("id").ToString();


        var attachedReceivedShareData = new
        {
            shareKind = "InPlace",
            properties = new
            {
                displayName = ReceivedShareDisplayName,
                sink = new
                {
                    storeKind = ReceiverStorageKind,
                    properties = new
                    {
                        containerName = ReceiverStorageContainer,
                        folder = ReceiverTargetFolderName,
                        mountPath = ReceiverTargetMountPath
                    },
                    storeReference = new
                    {
                        referenceName = ReceiverStorageResourceId,
                        type = "ArmResourceReference"
                    }
                }
            }
        };

        var receivedShare = await receivedSharesClient.CreateOrReplaceReceivedShareAsync(WaitUntil.Completed, ReceivedShareId, RequestContent.Create(attachedReceivedShareData));

        Console.ForegroundColor = ConsoleColor.Green;
        Console.WriteLine(receivedShare.Value);
        Console.ForegroundColor = Console.ForegroundColor;

        return receivedShare.Value;
    }

    public static async Task<List<T>> ToResultList<T>(this AsyncPageable<T> asyncPageable)
    {
        List<T> list = new List<T>();

        await foreach (T item in asyncPageable)
        {
            list.Add(item);
        }

        return list;
    }
}

Listar todas as partilhas recebidas

Este script lista todas as partilhas recebidas numa conta de armazenamento. Para utilizá-lo, certifique-se de que preenche estas variáveis:

ReceiverTenantId - o ID de Inquilino do Azure para o utilizador/serviço que está a receber os dados partilhados.
ReceiverPurviewAccountName - o nome da conta do Microsoft Purview onde os dados foram recebidos.
ReceiverStorageResourceId - o ID de recurso da conta de armazenamento onde os dados foram partilhados.
UseServiceTokenCredentials - (opcional) Se quiser utilizar um principal de serviço para receber as partilhas, defina-o como verdadeiro.
ReceiverClientId - (opcional) Se estiver a utilizar um principal de serviço para receber as partilhas, este é o ID da Aplicação (cliente) do principal de serviço.
ReceiverClientSecret - (opcional) Se estiver a utilizar um principal de serviço para receber as partilhas, adicione a chave de autenticação/segredo do cliente.
ReceiverPurviewEndPoint - Se estiver a utilizar a experiência clássica do Microsoft Purview, utilize $"https://{ReceiverPurviewAccountName}.purview.azure.com"; Se estiver a utilizar a nova experiência do Microsoft Purview, utilize https://api.purview-service.microsoft.com/

using Azure;
using Azure.Analytics.Purview.Sharing;
using Azure.Core;
using Azure.Identity;

public static class PurviewDataSharingQuickStart
{
    // [REQUIRED INPUTS] Set To Actual Values.
    private static string ReceiverTenantId = "<Receiver Indentity's Tenant ID>";
    private static string ReceiverPurviewAccountName = "<Receiver Purview Account Name>";

    private static string ReceiverStorageResourceId = "<Storage Account Resource Id that is housing shares>";

    //Use if using a service principal to list shares
    private static bool UseServiceTokenCredentials = false;
    private static string ReceiverClientId = "<Receiver Caller Application (Client) Id>";
    private static string ReceiverClientSecret = "<Receiver Caller Application (Client) Secret>";

    // General Configs
    private static string ReceiverPurviewEndPoint = $"https://{ReceiverPurviewAccountName}.purview.azure.com";
    private static string ReceiverShareEndPoint = $"{ReceiverPurviewEndPoint}/share";

    private static async Task Main(string[] args)
    {
        try
        {
            TokenCredential receiverCredentials = UseServiceTokenCredentials
            ? new ClientSecretCredential(ReceiverTenantId, ReceiverClientId, ReceiverClientSecret)
            : new DefaultAzureCredential(new DefaultAzureCredentialOptions { AuthorityHost = new Uri("https://login.windows.net"), TenantId = ReceiverTenantId });

            ReceivedSharesClient? receivedSharesClient = new ReceivedSharesClient(ReceiverShareEndPoint, receiverCredentials);

            var allReceivedShares = await receivedSharesClient.GetAllAttachedReceivedSharesAsync(ReceiverStorageResourceId).ToResultList();
            Console.WriteLine(allReceivedShares);
        }
        catch (Exception ex)
        {
            Console.ForegroundColor = ConsoleColor.Red;
            Console.WriteLine(ex);
            Console.ForegroundColor = Console.ForegroundColor;
        }
    }

    public static async Task<List<T>> ToResultList<T>(this AsyncPageable<T> asyncPageable)
    {
        List<T> list = new List<T>();

        await foreach (T item in asyncPageable)
        {
            list.Add(item);
        }

        return list;
    }
}

Este script permite-lhe atualizar a localização de armazenamento de uma partilha recebida. Tal como na criação de uma partilha recebida, adiciona as informações da conta de armazenamento onde pretende que os dados sejam alojados. Para utilizá-lo, certifique-se de que preenche estas variáveis:

ReceiverTenantId - o ID de Inquilino do Azure para o utilizador/serviço que está a receber os dados partilhados.
ReceiverPurviewAccountName – o nome da conta do Microsoft Purview onde os dados serão recebidos.
ReceiverStorageKind - BlobAccount ou AdlsGen2Account.
ReceiverStorageResourceId - o ID de recurso da conta de armazenamento onde os dados foram partilhados.
ReAttachStorageResourceId – o ID de recurso da conta de armazenamento onde os dados serão recebidos.
ReceiverStorageContainer – o nome do contentor onde os dados partilhados serão armazenados.
ReceiverTargetFolderName – o caminho da pasta para onde os dados partilhados serão armazenados.
ReceiverTargetMountPath - o caminho de montagem que pretende utilizar para armazenar os seus dados na pasta.
ReceivedShareDisplayName – o nome a apresentar da partilha recebida.
UseServiceTokenCredentials - (opcional) Se quiser utilizar um principal de serviço para receber as partilhas, defina-o como verdadeiro.
ReceiverClientId - (opcional) Se estiver a utilizar um principal de serviço para receber as partilhas, este é o ID da Aplicação (cliente) do principal de serviço.
ReceiverClientSecret - (opcional) Se estiver a utilizar um principal de serviço para receber as partilhas, adicione a chave de autenticação/segredo do cliente.
ReceiverPurviewEndPoint - Se estiver a utilizar a experiência clássica do Microsoft Purview, utilize $"https://{ReceiverPurviewAccountName}.purview.azure.com"; Se estiver a utilizar a nova experiência do Microsoft Purview, utilize https://api.purview-service.microsoft.com/

using Azure;
using Azure.Analytics.Purview.Sharing;
using Azure.Core;
using Azure.Identity;
using System.ComponentModel;
using System.Text.Json;

public static class PurviewDataSharingQuickStart
{
    // [REQUIRED INPUTS] Set To Actual Values.
    private static string ReceiverTenantId = "<Receiver Indentity's Tenant ID>";
    private static string ReceiverPurviewAccountName = "<Receiver Purview Account Name>";

    private static string ReceiverStorageKind = "<Receiver Storage Account Kind (BlobAccount / AdlsGen2Account)>";
    private static string ReceiverStorageResourceId = "<Storage Account Resource Id for the account where the share is currently attached.>";
    private static string ReAttachStorageResourceId = "<Storage Account Resource Id For Reattaching Received Share>";
    private static string ReceiverStorageContainer = "<Container Name To Receive Data Under>";
    private static string ReceiverTargetFolderName = "<Folder Name to Received Data Under>";
    private static string ReceiverTargetMountPath = "<Mount Path to Received Data Under>";

    private static string ReceivedShareDisplayName = "<Display name of your received share>";

    //Use if using a service principal to update the share
    private static bool UseServiceTokenCredentials = false;
    private static string ReceiverClientId = "<Receiver Caller Application (Client) Id>";
    private static string ReceiverClientSecret = "<Receiver Caller Application (Client) Secret>";

    // General Configs
    private static string ReceiverPurviewEndPoint = $"https://{ReceiverPurviewAccountName}.purview.azure.com";
    private static string ReceiverShareEndPoint = $"{ReceiverPurviewEndPoint}/share";

    private static async Task Main(string[] args)
    {
        try
        {

            Console.WriteLine($"{DateTime.Now.ToShortTimeString()}: UpdateReceivedShare - START");
            await Receiver_UpdateReceivedShare();
            Console.WriteLine($"{DateTime.Now.ToShortTimeString()}: UpdateReceivedShare - FINISH");
        }
        catch (Exception ex)
        {
            Console.ForegroundColor = ConsoleColor.Red;
            Console.WriteLine(ex);
            Console.ForegroundColor = Console.ForegroundColor;
        }
    }

    private static async Task<BinaryData> Receiver_UpdateReceivedShare()
    {

        TokenCredential receiverCredentials = UseServiceTokenCredentials
            ? new ClientSecretCredential(ReceiverTenantId, ReceiverClientId, ReceiverClientSecret)
            : new DefaultAzureCredential(new DefaultAzureCredentialOptions { AuthorityHost = new Uri("https://login.windows.net"), TenantId = ReceiverTenantId });

        ReceivedSharesClient? receivedSharesClient = new ReceivedSharesClient(ReceiverShareEndPoint, receiverCredentials);

        if (receivedSharesClient == null)
        {
            throw new InvalidEnumArgumentException("Invalid Received Shares Client.");
        }

        var attachedReceivedShareData = new
        {
            shareKind = "InPlace",
            properties = new
            {
                displayName = ReceivedShareDisplayName,
                sink = new
                {
                    storeKind = ReceiverStorageKind,
                    properties = new
                    {
                        containerName = ReceiverStorageContainer,
                        folder = ReceiverTargetFolderName,
                        mountPath = ReceiverTargetMountPath
                    },
                    storeReference = new
                    {
                        referenceName = ReAttachStorageResourceId,
                        type = "ArmResourceReference"
                    }
                }
            }
        };

        var allReceivedShares = await receivedSharesClient.GetAllAttachedReceivedSharesAsync(ReceiverStorageResourceId).ToResultList();

        var myReceivedShare = allReceivedShares.First(recShareDoc =>
        {
            var doc = JsonDocument.Parse(recShareDoc).RootElement;
            var props = doc.GetProperty("properties");
            return props.GetProperty("displayName").ToString() == ReceivedShareDisplayName;
        });

        Console.ForegroundColor = ConsoleColor.Green;
        Console.WriteLine("My Received Share Id: " + JsonDocument.Parse(myReceivedShare).RootElement.GetProperty("id").ToString());
        Console.ForegroundColor = Console.ForegroundColor;


        var ReceivedShareId = JsonDocument.Parse(myReceivedShare).RootElement.GetProperty("id").ToString();

        var receivedShare = await receivedSharesClient.CreateOrReplaceReceivedShareAsync(WaitUntil.Completed, ReceivedShareId, RequestContent.Create(attachedReceivedShareData));

        Console.ForegroundColor = ConsoleColor.Green;
        Console.WriteLine(receivedShare.Value);
        Console.ForegroundColor = Console.ForegroundColor;

        return receivedShare.Value;
    }

    public static async Task<List<T>> ToResultList<T>(this AsyncPageable<T> asyncPageable)
    {
        List<T> list = new List<T>();

        await foreach (T item in asyncPageable)
        {
            list.Add(item);
        }

        return list;
    }
}

Este script elimina uma partilha recebida. Para utilizá-lo, certifique-se de que preenche estas variáveis:

ReceiverTenantId - o ID de Inquilino do Azure para o utilizador/serviço que está a receber os dados partilhados.
ReceiverPurviewAccountName – o nome da conta do Microsoft Purview onde os dados serão recebidos.
ReceivedShareDisplayName – o nome a apresentar da partilha recebida.
ReceiverStorageResourceId - o ID de recurso da conta de armazenamento onde os dados foram partilhados.
UseServiceTokenCredentials - (opcional) Se quiser utilizar um principal de serviço para receber as partilhas, defina-o como verdadeiro.
ReceiverClientId - (opcional) Se estiver a utilizar um principal de serviço para receber as partilhas, este é o ID da Aplicação (cliente) do principal de serviço.
ReceiverClientSecret - (opcional) Se estiver a utilizar um principal de serviço para receber as partilhas, adicione a chave de autenticação/segredo do cliente.
ReceiverPurviewEndPoint - Se estiver a utilizar a experiência clássica do Microsoft Purview, utilize $"https://{ReceiverPurviewAccountName}.purview.azure.com"; Se estiver a utilizar a nova experiência do Microsoft Purview, utilize https://api.purview-service.microsoft.com/

using Azure;
using Azure.Analytics.Purview.Sharing;
using Azure.Core;
using Azure.Identity;
using System.Text.Json;

public static class PurviewDataSharingQuickStart
{
    // [REQUIRED INPUTS] Set To Actual Values.
    private static string ReceiverTenantId = "<Receiver Indentity's Tenant ID>";
    private static string ReceiverPurviewAccountName = "<Receiver Purview Account Name>";

    private static string ReceivedShareDisplayName = "<Display name of your received share>";

    private static string ReceiverStorageResourceId = "<Storage Account Resource Id for the account where the share is currently attached.>";

    //Use if using a service principal to delete share.
    private static bool UseServiceTokenCredentials = false;
    private static string ReceiverClientId = "<Receiver Caller Application (Client) Id>";
    private static string ReceiverClientSecret = "<Receiver Caller Application (Client) Secret>";

    // General Configs
    private static string ReceiverPurviewEndPoint = $"https://{ReceiverPurviewAccountName}.purview.azure.com";
    private static string ReceiverShareEndPoint = $"{ReceiverPurviewEndPoint}/share";

    private static async Task Main(string[] args)
    {
        try
        {
            TokenCredential receiverCredentials = UseServiceTokenCredentials
            ? new ClientSecretCredential(ReceiverTenantId, ReceiverClientId, ReceiverClientSecret)
            : new DefaultAzureCredential(new DefaultAzureCredentialOptions { AuthorityHost = new Uri("https://login.windows.net"), TenantId = ReceiverTenantId });

            ReceivedSharesClient? receivedSharesClient = new ReceivedSharesClient(ReceiverShareEndPoint, receiverCredentials);

            var allReceivedShares = await receivedSharesClient.GetAllAttachedReceivedSharesAsync(ReceiverStorageResourceId).ToResultList();

            var myReceivedShare = allReceivedShares.First(recShareDoc =>
            {
                var doc = JsonDocument.Parse(recShareDoc).RootElement;
                var props = doc.GetProperty("properties");
                return props.GetProperty("displayName").ToString() == ReceivedShareDisplayName;
            });

            Console.ForegroundColor = ConsoleColor.Green;
            Console.WriteLine("My Received Share Id: " + JsonDocument.Parse(myReceivedShare).RootElement.GetProperty("id").ToString());
            Console.ForegroundColor = Console.ForegroundColor;

            var ReceivedShareId = JsonDocument.Parse(myReceivedShare).RootElement.GetProperty("id").ToString();

            await receivedSharesClient.DeleteReceivedShareAsync(WaitUntil.Completed, ReceivedShareId);

            Console.ForegroundColor = ConsoleColor.Green;
            Console.WriteLine("Delete Complete");
            Console.ForegroundColor = Console.ForegroundColor;
        }
        catch (Exception ex)
        {
            Console.ForegroundColor = ConsoleColor.Red;
            Console.WriteLine(ex);
            Console.ForegroundColor = Console.ForegroundColor;
        }
    }
    public static async Task<List<T>> ToResultList<T>(this AsyncPageable<T> asyncPageable)
    {
        List<T> list = new List<T>();

        await foreach (T item in asyncPageable)
        {
            list.Add(item);
        }

        return list;
    }
}

Limpe os recursos

Para limpo os recursos criados para o início rápido, utilize as seguintes diretrizes:

No portal do Microsoft Purview, elimine a partilha enviada.
Elimine também a partilha recebida.
Depois de as partilhas serem eliminadas com êxito, elimine o contentor de destino e a pasta que o Microsoft Purview criou na sua conta de armazenamento de destino quando recebeu dados partilhados.

Partilhar via

Pré-requisitos

Pré-requisitos do Microsoft Purview

Pré-requisitos da conta de Armazenamento do Azure

Funções necessárias

Visual Studio

Azure .NET SDK

Utilizar um principal de serviço

Criar um projeto do Visual Studio

Instalar pacotes NuGet

Enviar convite a um utilizador

Enviar convite para um serviço

Listar partilhas enviadas

Eliminar destinatário

Listar todas as partilhas recebidas

Limpe os recursos

Próximas etapas

Comentários

Recursos adicionais

Partilhar via

Início Rápido: Partilhar e receber dados com o SDK .NET Compartilhamento de Dados do Microsoft Purview

Pré-requisitos

Pré-requisitos do Microsoft Purview

Pré-requisitos da conta de Armazenamento do Azure

Funções necessárias

Visual Studio

Azure .NET SDK

Utilizar um principal de serviço

Criar um projeto do Visual Studio

Instalar pacotes NuGet

Criar uma partilha enviada

Enviar convite a um utilizador

Enviar convite para um serviço

Listar partilhas enviadas

Listar todos os destinatários da partilha

Eliminar destinatário

Eliminar partilha enviada

Criar uma partilha recebida

Listar todas as partilhas recebidas

Atualizar partilha recebida

Eliminar partilha recebida

Limpe os recursos

Próximas etapas

Comentários

Recursos adicionais