Copiar e transformar dados na instância gerenciada do Azure SQL usando o pipeline do Azure Data Factory ou Synapse Analytics

APLICA-SE A: Azure Data Factory Azure Synapse Analytics

Este artigo descreve como usar a Atividade de Cópia para copiar dados de e para a Instância Gerenciada de SQL do Azure e usar o Fluxo de Dados para transformar dados na Instância Gerenciada de SQL do Azure. Para saber mais, leia o artigo introdutório do Azure Data Factory e do Synapse Analytics.

Funcionalidades com suporte

Este conector de Instância Gerenciada de SQL do Azure tem suporte para as seguintes funcionalidades:

① Runtime de integração do Azure ② Runtime de integração auto-hospedada

Para a atividade Copy, este conector do Banco de Dados SQL do Azure dá suporte a estas funções:

• Copiar dados usando a autenticação de token do Microsoft Entra e autenticação do SQL com uma entidade de serviço ou identidades gerenciadas para os recursos do Azure.
• Como uma origem, recuperar dados usando uma consulta SQL ou procedimento armazenado. Também é possível optar por copiar paralelamente da origem da MI de SQL, consulte a seção cópia paralela da MI de SQL para obter detalhes.
• Como um coletor, criar automaticamente a tabela de destino, se não existir uma, com base no esquema de origem; acrescentar dados a uma tabela ou invocar um procedimento armazenado com lógica personalizada durante a cópia.

Pré-requisitos

Para acessar o ponto de extremidade público da Instância Gerenciada de SQL, você pode usar um runtime de integração do Azure gerenciada. Certifique-se de habilitar o ponto de extremidade público e também permitir o tráfego do ponto de extremidade público no grupo de segurança de rede para que o serviço possa se conectar ao seu banco de dados. Para obter mais informações, consulte estas diretrizes.

Para acessar o ponto de extremidade privado da Instância Gerenciada de SQL, configure um runtime de integração auto-hospedada que possa acessar o banco de dados. Se você provisionar o runtime de integração auto-hospedada na mesma rede virtual que sua instância gerenciada, verifique se o computador do Integration Runtime está em uma sub-rede diferente de sua instância gerenciada. Se você provisionar seu runtime de integração auto-hospedada em uma rede virtual diferente de sua instância gerenciada, poderá usar um emparelhamento de rede virtual ou uma rede virtual para a conexão de rede virtual. Para obter mais informações, confira Conectar seu aplicativo à Instância Gerenciada de SQL.

Introdução

Para executar a atividade de Cópia com um pipeline, será possível usar as ferramentas ou os SDKs abaixo:

• A ferramenta Copiar Dados
• O portal do Azure
• O SDK do .NET
• O SDK do Python
• PowerShell do Azure
• A API REST
• O modelo do Azure Resource Manager

Criar um serviço vinculado para uma Instância Gerenciada do SQL do Azure usando a interface do usuário

Use as etapas a seguir para criar um serviço vinculado para uma Instância Gerenciada do SQL na interface do usuário do portal do Azure.

1. Navegue até a guia Gerenciar no workspace do Azure Data Factory ou do Synapse e selecione Serviços Vinculados. Depois, clique em Novo:

   • Azure Data Factory
   • Azure Synapse

   

2. Pesquise por SQL e selecione o conector da Instância Gerenciada do Azure SQL Server.

   

3. Configure os detalhes do serviço, teste a conexão e crie o novo serviço vinculado.

   

Detalhes da configuração do conector

As seções a seguir fornecem detalhes sobre as propriedades que são usadas para definir entidades do Azure Data Factory específicas para o conector de Instância Gerenciada de SQL.

Propriedades do serviço vinculado

A versão recomendada do conector da Instância Gerenciada de SQL do Azure dá suporte ao TLS 1.3. Consulte esta seção para atualizar a versão do conector da Instância Gerenciada de SQL do Azure daquele Herdado. Para obter os detalhes da propriedade, consulte as seções correspondentes.

• Versão recomendada
• Versão herdada

Versão recomendada

Essas propriedades genéricas têm suporte de um serviço vinculado do Instância Gerenciada de SQL do Azure quando você aplica a versão Recomendada:

Consulte a tabela abaixo para obter as propriedades de conexão adicionais:

Autenticação do SQL

Para usar a autenticação SQL, além das propriedades genéricas descritas na seção anterior, especifique as seguintes propriedades:

Exemplo 1: usar a autenticação SQL

{
    "name": "AzureSqlMILinkedService",
    "properties": {
        "type": "AzureSqlMI",
        "typeProperties": {
            "server": "<name or network address of the SQL server instance>",
            "database": "<database name>",
            "encrypt": "<encrypt>",
            "trustServerCertificate": false,
            "authenticationType": "SQL",
            "userName": "<user name>",
            "password": {
                "type": "SecureString",
                "value": "<password>"
            }
        },
        "connectVia": {
            "referenceName": "<name of Integration Runtime>",
            "type": "IntegrationRuntimeReference"
        }
    }
}

Exemplo 2: usar a autenticação SQL com senha no Azure Key Vault

{
    "name": "AzureSqlMILinkedService",
    "properties": {
        "type": "AzureSqlMI",
        "typeProperties": {
            "server": "<name or network address of the SQL server instance>",
            "database": "<database name>",
            "encrypt": "<encrypt>",
            "trustServerCertificate": false,
            "authenticationType": "SQL",
            "userName": "<user name>",
            "password": { 
                "type": "AzureKeyVaultSecret", 
                "store": { 
                    "referenceName": "<Azure Key Vault linked service name>", 
                    "type": "LinkedServiceReference" 
                }, 
                "secretName": "<secretName>" 
            }
        },
        "connectVia": {
            "referenceName": "<name of Integration Runtime>",
            "type": "IntegrationRuntimeReference"
        }
    }
}

Exemplo 3: usar a autenticação SQL com Always Encrypted

{
    "name": "AzureSqlMILinkedService",
    "properties": {
        "type": "AzureSqlMI",
        "typeProperties": {
            "server": "<name or network address of the SQL server instance>",
            "database": "<database name>",
            "encrypt": "<encrypt>",
            "trustServerCertificate": false,
            "authenticationType": "SQL",
            "userName": "<user name>",
            "password": {
                "type": "SecureString",
                "value": "<password>"
            }
        },
        "alwaysEncryptedSettings": {
            "alwaysEncryptedAkvAuthType": "ServicePrincipal",
            "servicePrincipalId": "<service principal id>",
            "servicePrincipalKey": {
                "type": "SecureString",
                "value": "<service principal key>"
            }
        },
        "connectVia": {
            "referenceName": "<name of Integration Runtime>",
            "type": "IntegrationRuntimeReference"
        }
    }
}

Autenticação de entidade de serviço

Para usar a autenticação de entidade de serviço, além das propriedades genéricas descritas na seção anterior, especifique as propriedades a seguir

Você também precisa seguir as etapas abaixo:

1. Siga as etapas para Provisionar um administrador do Microsoft Entra na sua Instância Gerenciada.

2. Criar um aplicativo do Microsoft Entra no portal do Azure. Anote o nome do aplicativo e os seguintes valores que definem o serviço vinculado:

   • ID do aplicativo
   • Chave do aplicativo
   • ID do locatário

3. Crie logons para a entidade de serviço. No SQL Server Management Studio (SSMS), conecte-se à sua instância gerenciada usando uma conta do SQL Server que seja um sysadmin. No banco de dados mestre, execute o seguinte T-SQL:

   CREATE LOGIN [your application name] FROM EXTERNAL PROVIDER
   

4. Crie usuários de banco de dados contidos para o diretor de serviços. Conecte-se ao banco de dados do ou para o qual você deseja copiar dados. Execute o seguinte T-SQL:

   CREATE USER [your application name] FROM EXTERNAL PROVIDER
   

5. Conceda ao principal de serviço as permissões necessárias, como faria normalmente para usuários do SQL e outros. Execute o código a seguir. Para mais opções, confira este documento.

   ALTER ROLE [role name e.g. db_owner] ADD MEMBER [your application name]
   

6. Configure um serviço vinculado de Instância Gerenciada de SQL.

Exemplo: usar autenticação de entidade de serviço

{
    "name": "AzureSqlDbLinkedService",
    "properties": {
        "type": "AzureSqlMI",
        "typeProperties": {
            "server": "<name or network address of the SQL server instance>",
            "database": "<database name>",
            "encrypt": "<encrypt>",
            "trustServerCertificate": false,
            "hostNameInCertificate": "<host name>",
            "authenticationType": "ServicePrincipal",
            "servicePrincipalId": "<service principal id>",
            "servicePrincipalCredential": {
                "type": "SecureString",
                "value": "<application key>"
            },
            "tenant": "<tenant info, e.g. microsoft.onmicrosoft.com>"
        },
        "connectVia": {
            "referenceName": "<name of Integration Runtime>",
            "type": "IntegrationRuntimeReference"
        }
    }
}

Autenticação de identidade gerenciada atribuída pelo sistema

É possível associar um data factory ou um workspace do Synapse a uma identidade gerenciada atribuída pelo sistema para recursos do Azure que representa o serviço ao autenticar em outros serviços do Azure. Você pode usar essa identidade gerenciada para autenticação da Instância Gerenciada de SQL. O serviço designado pode acessar dados do banco de dados e copiá-los para o banco de dados usando essa identidade.

Para usar a autenticação de identidade gerenciada atribuída pelo sistema, especifique as propriedades genéricas descritas na seção anterior e siga estas etapas.

1. Siga as etapas para Provisionar um administrador do Microsoft Entra na sua Instância Gerenciada.

2. Crie logons para a identidade gerenciada atribuída pelo sistema. No SQL Server Management Studio (SSMS), conecte-se à sua instância gerenciada usando uma conta do SQL Server que seja um sysadmin. No banco de dados mestre, execute o seguinte T-SQL:

   CREATE LOGIN [your_factory_or_workspace_ name] FROM EXTERNAL PROVIDER
   

3. Crie usuários de banco de dados contidos para a identidade gerenciada atribuída pelo sistema. Conecte-se ao banco de dados do ou para o qual você deseja copiar dados. Execute o seguinte T-SQL:

   CREATE USER [your_factory_or_workspace_name] FROM EXTERNAL PROVIDER
   

4. Conceda à identidade gerenciada atribuída pelo sistema as permissões necessárias como você faria normalmente para usuários de SQL e outros. Execute o código a seguir. Para mais opções, confira este documento.

   ALTER ROLE [role name e.g. db_owner] ADD MEMBER [your_factory_or_workspace_name]
   

5. Configure um serviço vinculado de Instância Gerenciada de SQL.

Exemplo: usa a autenticação de identidade gerenciada atribuída pelo sistema

{
    "name": "AzureSqlDbLinkedService",
    "properties": {
        "type": "AzureSqlMI",
        "typeProperties": {
            "server": "<name or network address of the SQL server instance>",
            "database": "<database name>",
            "encrypt": "<encrypt>",
            "trustServerCertificate": false,
            "authenticationType": "SystemAssignedManagedIdentity"
        },
        "connectVia": {
            "referenceName": "<name of Integration Runtime>",
            "type": "IntegrationRuntimeReference"
        }
    }
}

Autenticação de identidade gerenciada atribuída pelo usuário

É possível associar um data factory ou um workspace do Synapse a uma identidade gerenciada atribuída pelo usuário que representa o serviço ao autenticar em outros serviços do Azure. Você pode usar essa identidade gerenciada para autenticação da Instância Gerenciada de SQL. O serviço designado pode acessar dados do banco de dados e copiá-los para o banco de dados usando essa identidade.

Para usar a autenticação de identidade gerenciada atribuída pelo usuário, além das propriedades genéricas descritas na seção anterior, especifique as seguintes propriedades:

Você também precisa seguir as etapas abaixo:

1. Siga as etapas para Provisionar um administrador do Microsoft Entra na sua Instância Gerenciada.

2. Crie logons para a identidade gerenciada atribuída pelo usuário. No SQL Server Management Studio (SSMS), conecte-se à sua instância gerenciada usando uma conta do SQL Server que seja um sysadmin. No banco de dados mestre, execute o seguinte T-SQL:

   CREATE LOGIN [your_factory_or_workspace_ name] FROM EXTERNAL PROVIDER
   

3. Crie usuários de banco de dados contidos para a identidade gerenciada atribuída pelo usuário. Conecte-se ao banco de dados do ou para o qual você deseja copiar dados. Execute o seguinte T-SQL:

   CREATE USER [your_factory_or_workspace_name] FROM EXTERNAL PROVIDER
   

4. Crie uma ou várias identidades gerenciadas atribuídas pelo usuário e conceda à identidade gerenciada atribuída pelo usuário as permissões necessárias como você normalmente faz para SQL usuários e outros. Execute o código a seguir. Para mais opções, confira este documento.

   ALTER ROLE [role name e.g. db_owner] ADD MEMBER [your_factory_or_workspace_name]
   

5. Atribua uma ou várias identidades gerenciadas atribuídas pelo usuário a seu data factory e crie credenciais para cada identidade gerenciada atribuída pelo usuário.

6. Configure um serviço vinculado de Instância Gerenciada de SQL.

Exemplo: usa a autenticação de identidade gerenciada atribuída pelo usuário

{
    "name": "AzureSqlDbLinkedService",
    "properties": {
        "type": "AzureSqlMI",
        "typeProperties": {
            "server": "<name or network address of the SQL server instance>",
            "database": "<database name>",
            "encrypt": "<encrypt>",
            "trustServerCertificate": false,
            "authenticationType": "UserAssignedManagedIdentity",
            "credential": {
                "referenceName": "credential1",
                "type": "CredentialReference"
            }
        },
        "connectVia": {
            "referenceName": "<name of Integration Runtime>",
            "type": "IntegrationRuntimeReference"
        }
    }
}

Versão herdada

Essas propriedades genéricas têm suporte de um serviço vinculado do Instância Gerenciada de SQL do Azure quando você aplica a versão herdada:

Para diferentes tipos de autenticação, consulte as seguintes seções sobre propriedades específicas e pré-requisitos, respectivamente:

• Autenticação SQL para a versão herdada
• Autenticação da entidade de serviço para a versão herdada
• Autenticação de identidade gerenciada atribuída pelo sistema para a versão herdada
• Autenticação de identidade gerenciada atribuída pelo usuário para a versão herdada

Autenticação SQL para a versão herdada

Para usar a autenticação SQL, especifique as propriedades genéricas descritas na seção anterior.

Autenticação da entidade de serviço para a versão herdada

Para usar a autenticação de entidade de serviço, além das propriedades genéricas descritas na seção anterior, especifique as seguintes propriedades:

Você também precisa seguir as etapas na autenticação da entidade de serviço para conceder a permissão correspondente.

Autenticação de identidade gerenciada atribuída pelo sistema para a versão herdada

Para usar a autenticação de identidade gerenciada atribuída pelo sistema, siga a mesma etapa para a versão recomendada na autenticação de identidade gerenciada atribuída pelo sistema.

Autenticação de identidade gerenciada atribuída pelo usuário para versão herdada

Para usar a autenticação de identidade gerenciada atribuída pelo usuário, siga a mesma etapa para a versão recomendada na autenticação de identidade gerenciada atribuída pelo usuário.

Propriedades do conjunto de dados

Para obter uma lista completa das seções e das propriedades disponíveis para uso para definir conjuntos de dados, confira o artigo sobre conjuntos de dados. Esta seção fornece uma lista das propriedades com suporte pelo conjunto de dados da Instância Gerenciada de SQL.

Para copiar dados de e para a Instância Gerenciada de SQL, há suporte para as seguintes propriedades:

Exemplo

{
    "name": "AzureSqlMIDataset",
    "properties":
    {
        "type": "AzureSqlMITable",
        "linkedServiceName": {
            "referenceName": "<SQL Managed Instance linked service name>",
            "type": "LinkedServiceReference"
        },
        "schema": [ < physical schema, optional, retrievable during authoring > ],
        "typeProperties": {
            "schema": "<schema_name>",
            "table": "<table_name>"
        }
    }
}

Propriedades da atividade de cópia

Para obter uma lista completa das seções e propriedades disponíveis para uso para definir atividades, confia o artigo Pipelines. Esta seção fornece uma lista das propriedades com suporte da fonte de dados e coletor da Instância Gerenciada de SQL.

Instância Gerenciada de SQL como uma origem

Para copiar dados da Instância Gerenciada de SQL há suporte para as seguintes propriedades na seção da origem da atividade de cópia:

Observe os seguintes pontos:

• Se sqlReaderQuery for especificado para SqlMISource, a atividade de cópia executará essa consulta na origem da Instância Gerenciada de SQL para obter os dados. Você também pode especificar um procedimento armazenado especificando o sqlReaderStoredProcedureName e o storedProcedureParameters se o procedimento armazenado usa parâmetros.
• ao usar um procedimento armazenado na origem para recuperar dados, observe que, se o procedimento armazenado for projetado para retornar um esquema diferente quando um valor de parâmetro diferente for passado, você poderá ter uma falha ou um resultado inesperado ao importar o esquema da interface do usuário ou ao copiar dados para o banco de dados SQL com a criação automática de tabela.

Exemplo: usar uma consulta SQL

"activities":[
    {
        "name": "CopyFromAzureSqlMI",
        "type": "Copy",
        "inputs": [
            {
                "referenceName": "<SQL Managed Instance input dataset name>",
                "type": "DatasetReference"
            }
        ],
        "outputs": [
            {
                "referenceName": "<output dataset name>",
                "type": "DatasetReference"
            }
        ],
        "typeProperties": {
            "source": {
                "type": "SqlMISource",
                "sqlReaderQuery": "SELECT * FROM MyTable"
            },
            "sink": {
                "type": "<sink type>"
            }
        }
    }
]

Exemplo: usar um procedimento armazenado

"activities":[
    {
        "name": "CopyFromAzureSqlMI",
        "type": "Copy",
        "inputs": [
            {
                "referenceName": "<SQL Managed Instance input dataset name>",
                "type": "DatasetReference"
            }
        ],
        "outputs": [
            {
                "referenceName": "<output dataset name>",
                "type": "DatasetReference"
            }
        ],
        "typeProperties": {
            "source": {
                "type": "SqlMISource",
                "sqlReaderStoredProcedureName": "CopyTestSrcStoredProcedureWithParameters",
                "storedProcedureParameters": {
                    "stringData": { "value": "str3" },
                    "identifier": { "value": "$$Text.Format('{0:yyyy}', <datetime parameter>)", "type": "Int"}
                }
            },
            "sink": {
                "type": "<sink type>"
            }
        }
    }
]

A definição do procedimento armazenado

CREATE PROCEDURE CopyTestSrcStoredProcedureWithParameters
(
    @stringData varchar(20),
    @identifier int
)
AS
SET NOCOUNT ON;
BEGIN
    select *
    from dbo.UnitTestSrcTable
    where dbo.UnitTestSrcTable.stringData != stringData
    and dbo.UnitTestSrcTable.identifier != identifier
END
GO

Instância Gerenciada de SQL como um coletor

Para copiar dados da Instância Gerenciada de SQL, há suporte para as seguintes propriedades na seção do coletor da atividade de cópia:

Exemplo 1: acrescentar dados

"activities":[
    {
        "name": "CopyToAzureSqlMI",
        "type": "Copy",
        "inputs": [
            {
                "referenceName": "<input dataset name>",
                "type": "DatasetReference"
            }
        ],
        "outputs": [
            {
                "referenceName": "<SQL Managed Instance output dataset name>",
                "type": "DatasetReference"
            }
        ],
        "typeProperties": {
            "source": {
                "type": "<source type>"
            },
            "sink": {
                "type": "SqlMISink",
                "tableOption": "autoCreate",
                "writeBatchSize": 100000
            }
        }
    }
]

Exemplo 2: invocar um procedimento armazenado durante a cópia

Saiba mais detalhes em Invocar um procedimento armazenado de um coletor de MI de SQL.

"activities":[
    {
        "name": "CopyToAzureSqlMI",
        "type": "Copy",
        "inputs": [
            {
                "referenceName": "<input dataset name>",
                "type": "DatasetReference"
            }
        ],
        "outputs": [
            {
                "referenceName": "<SQL Managed Instance output dataset name>",
                "type": "DatasetReference"
            }
        ],
        "typeProperties": {
            "source": {
                "type": "<source type>"
            },
            "sink": {
                "type": "SqlMISink",
                "sqlWriterStoredProcedureName": "CopyTestStoredProcedureWithParameters",
                "storedProcedureTableTypeParameterName": "MyTable",
                "sqlWriterTableType": "MyTableType",
                "storedProcedureParameters": {
                    "identifier": { "value": "1", "type": "Int" },
                    "stringData": { "value": "str1" }
                }
            }
        }
    }
]

Exemplo 3: Dados upsert

"activities":[
    {
        "name": "CopyToAzureSqlMI",
        "type": "Copy",
        "inputs": [
            {
                "referenceName": "<input dataset name>",
                "type": "DatasetReference"
            }
        ],
        "outputs": [
            {
                "referenceName": "<SQL Managed Instance output dataset name>",
                "type": "DatasetReference"
            }
        ],
        "typeProperties": {
            "source": {
                "type": "<source type>"
            },
            "sink": {
                "type": "SqlMISink",
                "tableOption": "autoCreate",
                "writeBehavior": "upsert",
                "upsertSettings": {
                    "useTempDB": true,
                    "keys": [
                        "<column name>"
                    ]
                },            
            }
        }
    }
]

Cópia paralela do MI SQL

O conector de Instância Gerenciada de SQL na atividade de cópia fornece particionamento de dados interno para copiar dados em paralelo. Você pode encontrar opções de particionamento de dados na guia Origem da atividade de cópia.

Quando você habilita a cópia particionada, a atividade de cópia executa consultas paralelas com relação à origem da MI de SQL para carregar dados por partições. O grau paralelo é controlado pela configuração do parallelCopies na atividade de cópia. Por exemplo, ao definir parallelCopies como quatro, o serviço gera e executa simultaneamente quatro consultas com base na opção de partição especificada e nas configurações, e cada consulta recupera uma parte dos dados do SQL MI.

É recomendável habilitar a cópia paralela com o particionamento de dados, especialmente quando você carrega grandes quantidades da MI de SQL. Veja a seguir as configurações sugeridas para cenários diferentes. Ao copiar dados para o armazenamento de dados baseado em arquivo, recomendamos gravá-los em uma pasta como vários arquivos (apenas especifique o nome da pasta) para ter um desempenho melhor do que gravar em um arquivo.

Melhores práticas para carregar dados com a opção de partição:

1. Escolha a coluna distinta como coluna de partição (como chave primária ou chave exclusiva) para evitar a distorção de dados.
2. Se a tabela tiver uma partição interna, use a opção de partição "Partições físicas da tabela" para ter um melhor desempenho.
3. Se você usa o Azure Integration Runtime para copiar dados, pode definir "DIUs (unidades de integração de dados)" maiores (>4) para utilizar mais recursos de computação. Verifique os cenários aplicáveis.
4. O "grau de paralelismo de cópia" controla os números de partições. Às vezes, definir um número muito grande afeta o desempenho; é recomendável definir esse número como (DIU ou número de nós de IR auto-hospedados) * (2 a 4).

Exemplo: carregamento completo de uma tabela grande com partições físicas

"source": {
    "type": "SqlMISource",
    "partitionOption": "PhysicalPartitionsOfTable"
}

Exemplo: consulta com a partição do intervalo dinâmico

"source": {
    "type": "SqlMISource",
    "query": "SELECT * FROM <TableName> WHERE ?DfDynamicRangePartitionCondition AND <your_additional_where_clause>",
    "partitionOption": "DynamicRange",
    "partitionSettings": {
        "partitionColumnName": "<partition_column_name>",
        "partitionUpperBound": "<upper_value_of_partition_column (optional) to decide the partition stride, not as data filter>",
        "partitionLowerBound": "<lower_value_of_partition_column (optional) to decide the partition stride, not as data filter>"
    }
}

Exemplo de consulta para verificar a partição física

SELECT DISTINCT s.name AS SchemaName, t.name AS TableName, pf.name AS PartitionFunctionName, c.name AS ColumnName, iif(pf.name is null, 'no', 'yes') AS HasPartition
FROM sys.tables AS t
LEFT JOIN sys.objects AS o ON t.object_id = o.object_id
LEFT JOIN sys.schemas AS s ON o.schema_id = s.schema_id
LEFT JOIN sys.indexes AS i ON t.object_id = i.object_id 
LEFT JOIN sys.index_columns AS ic ON ic.partition_ordinal > 0 AND ic.index_id = i.index_id AND ic.object_id = t.object_id 
LEFT JOIN sys.columns AS c ON c.object_id = ic.object_id AND c.column_id = ic.column_id 
LEFT JOIN sys.partition_schemes ps ON i.data_space_id = ps.data_space_id 
LEFT JOIN sys.partition_functions pf ON pf.function_id = ps.function_id 
WHERE s.name='[your schema]' AND t.name = '[your table name]'

Se a tabela tiver uma partição física, você verá "HasPartition" como "yes" conforme segue.

Melhor prática para carregar dados na Instância Gerenciada de SQL

Ao copiar dados para a Instância Gerenciada de SQL, pode ser necessário um comportamento de gravação diferente:

• Acrescentar: meus dados de origem têm apenas registros novos.
• Upsert: meus dados de origem têm inserções e atualizações.
• Substituir: Eu quero recarregar toda a tabela de dimensões a cada vez.
• Gravar com lógica personalizada: preciso de processamento extra antes da inserção final na tabela de destino.

Confira as respectivas seções sobre como configurar e as práticas recomendadas.

Acrescentar dados

Acrescentar dados é o comportamento padrão do conector do coletor da Instância Gerenciada de SQL. O serviço faz uma inserção em massa para gravar na tabela de maneira eficiente. Você pode configurar a origem e o coletor de acordo com a atividade Copy.

Upsert data

A atividade Copy agora dá suporte ao carregamento nativo de dados em uma tabela temporária de banco de dados e, em seguida, atualize os dados na tabela de coletor se a chave existir e, caso contrário, insira novos dados. Para saber mais sobre as configurações de upsert em atividades de cópia, confira Instância Gerenciada de SQL como coletor.

Substituir a tabela inteira

Você pode configurar a propriedade preCopyScript em um coletor de atividade de cópia. Nesse caso, para cada atividade Copy executada, o serviço executa primeiro o script. Em seguida, ele executa a cópia para inserir os dados. Por exemplo, para substituir a tabela inteira pelos dados mais recentes, especifique um script para excluir primeiro todos os registros, antes de carregar em massa os novos dados da origem.

Gravar dados com lógica personalizada

As etapas para gravar dados com lógica personalizada são semelhantes às descritas na seção de dados Upsert. Quando você precisa aplicar processamento extra antes da inserção final dos dados de origem na tabela de destino, você pode carregar em uma tabela de preparo e, em seguida, invocar a atividade de procedimento armazenado, ou invocar um procedimento armazenado no coletor de atividade de cópia para aplicar dados.

Invocar um procedimento armazenado de um coletor SQL

Ao copiar dados para a Instância Gerenciada de SQL, você também pode configurar e invocar um procedimento armazenado especificado pelo usuário com parâmetros adicionais em cada lote da tabela de origem. O recurso de procedimento armazenado se beneficia de parâmetros com valores de tabela.

Você pode usar um procedimento armazenado quando os mecanismos internos de cópia não atendem à finalidade. Um exemplo é quando você deseja aplicar processamento adicional antes da inserção final dos dados de origem na tabela de destino. Alguns exemplos de processamento extra são quando você deseja mesclar colunas, pesquisar valores adicionais e inserir em mais de uma tabela.

O exemplo a seguir mostra como usar um procedimento armazenado para fazer um upsert em uma tabela no banco de dados do SQL Server. Suponha que os dados de entrada e a tabela de Marketing do coletor tenham três colunas cada um: ID do perfil, Estado e Categoria. Faça o upsert com base na coluna ProfileID e aplique-o apenas a uma categoria específica denominada "ProductA".

1. No banco de dados, defina o tipo de tabela com o mesmo nome que sqlWriterTableType. O esquema do tipo de tabela é o mesmo que o esquema retornado pelos dados de entrada.

   CREATE TYPE [dbo].[MarketingType] AS TABLE(
       [ProfileID] [varchar](256) NOT NULL,
       [State] [varchar](256) NOT NULL,
       [Category] [varchar](256) NOT NULL
   )
   

2. No banco de dados, defina o procedimento armazenado com o mesmo nome que sqlWriterStoredProcedureName. Ele manipula os dados de entrada da sua origem especificada e mescla na tabela de saída. O nome do parâmetro do tipo de tabela no procedimento armazenado deve ser o mesmo que o tableName definido no conjunto de dados.

   CREATE PROCEDURE spOverwriteMarketing @Marketing [dbo].[MarketingType] READONLY, @category varchar(256)
   AS
   BEGIN
   MERGE [dbo].[Marketing] AS target
   USING @Marketing AS source
   ON (target.ProfileID = source.ProfileID and target.Category = @category)
   WHEN MATCHED THEN
       UPDATE SET State = source.State
   WHEN NOT MATCHED THEN
       INSERT (ProfileID, State, Category)
       VALUES (source.ProfileID, source.State, source.Category);
   END
   

3. No pipeline, defina a seção coletor do MI de SQL na atividade de cópia da seguinte maneira:

   "sink": {
       "type": "SqlMISink",
       "sqlWriterStoredProcedureName": "spOverwriteMarketing",
       "storedProcedureTableTypeParameterName": "Marketing",
       "sqlWriterTableType": "MarketingType",
       "storedProcedureParameters": {
           "category": {
               "value": "ProductA"
           }
       }
   }
   

Propriedades do fluxo de dados de mapeamento

Ao transformar dados no fluxo de dados de mapeamento, você pode ler e gravar em tabelas da Instância Gerenciada de SQL do Azure. Para obter mais informações, confira transformação de origem e transformação do coletor nos fluxos de dados de mapeamento.

Transformação de origem

A tabela abaixo lista as propriedades com suporte da fonte da Instância Gerenciada de SQL do Azure. Você pode editar essas propriedades na guia Opções de origem.

CREATE PROC CTESP @query nvarchar(max)
AS
BEGIN
EXECUTE sp_executesql @query;
END

Exemplo de script de origem da Instância Gerenciada de SQL do Azure

Quando você usa a Instância Gerenciada de SQL do Azure como tipo de origem, o script de fluxo de dados associado é:

source(allowSchemaDrift: true,
    validateSchema: false,
    isolationLevel: 'READ_UNCOMMITTED',
    query: 'select * from MYTABLE',
    format: 'query') ~> SQLMISource

Transformação de coletor

A tabela abaixo lista as propriedades com suporte pelo coletor de Instância Gerenciada de SQL do Azure. Você pode editar essas propriedades na guia Opções do coletor.

Exemplo de script de coletor de Instância Gerenciada de SQL do Azure

Quando você usa a Instância Gerenciada de SQL do Azure como tipo de coletor, o script do fluxo de dados associado é:

IncomingStream sink(allowSchemaDrift: true,
    validateSchema: false,
    deletable:false,
    insertable:true,
    updateable:true,
    upsertable:true,
    keys:['keyColumn'],
    format: 'table',
    skipDuplicateMapInputs: true,
    skipDuplicateMapOutputs: true) ~> SQLMISink

Pesquisar propriedades de atividade

Para saber detalhes sobre as propriedades, verifique Atividade de pesquisa.

Propriedades de atividade GetMetadata

Para saber detalhes sobre as propriedades, verifique Atividade GetMetadata

Mapeamento do tipo de dados para a Instância Gerenciada de SQL

Quando dados são copiados para e da Instância Gerenciada de SQL, os seguintes mapeamentos são usados a partir dos tipos de dados da Instância Gerenciada de SQL para os tipos de dados provisórios usados internamente para o serviço. Para saber mais sobre como a atividade de cópia mapeia do tipo de dados e esquema de origem para o coletor, confira Mapeamentos de tipo de dados e esquema.

Como usar o Always Encrypted

Ao copiar dados de/para a Instância Gerenciada de SQL com Always Encrypted, siga as etapas abaixo:

1. Armazene a chave mestra de coluna (CMK) em um Azure Key Vault. Saiba mais sobre como configurar o Always Encrypted usando o Azure Key Vault

2. Confirme se concede acesso ao cofre de chaves onde a CMK (chave mestra de coluna) está armazenada. Confira este artigo para obter as permissões necessárias.

3. Crie um serviço vinculado para se conectar ao banco de dados SQL e habilite a função “Always Encrypted” usando a identidade gerenciada ou a entidade de serviço.

Captura de dados de alterações nativas

O Azure Data Factory pode dar suporte a recursos de captura de dados de alterações nativas para SQL Server, BD do SQL do Azure e MI do SQL do Azure. Os dados alterados, incluindo a inserção, atualização e exclusão de linha em armazenamentos SQL, poderão ser detectados e extraídos automaticamente pelo fluxo de dados de mapeamento do ADF. Com a experiência sem código no mapeamento de fluxo de dados, os usuários poderão obter facilmente o cenário de replicação de dados de repositórios SQL anexando um banco de dados como o repositório de destino. Além disso, os usuários também poderão redigir qualquer lógica de transformação de dados para obter um cenário de ETL incremental a partir de repositórios SQL.

Mantenha o pipeline e o nome da atividade inalterados para que o ponto de verificação possa ser registrado pelo ADF para que você receba automaticamente os dados alterados da última execução. Se você alterar o nome do pipeline ou da atividade, o ponto de verificação será redefinido, o que fará com que você comece do início ou receba alterações a partir de agora na próxima execução. Se você quiser alterar o nome do pipeline ou da atividade, mas ainda manter o ponto de verificação para obter os dados alterados da última execução automaticamente, use sua própria chave de ponto de verificação na atividade do fluxo de dados para conseguir isso.

Ao depurar o pipeline, esse recurso funcionará da mesma forma. Tenha em mente que o ponto de verificação será redefinido quando você atualizar o navegador durante a execução da depuração. Depois que estiver satisfeito com o resultado do pipeline da sequência de depuração, você poderá publicar e disparar o pipeline. Ao disparar pela primeira vez o pipeline publicado, ele será reiniciado automaticamente do início ou passará a obter alterações desse momento em diante.

Na seção de monitoramento, sempre existe a possibilidade de reexecutar um pipeline. Ao fazer isso, os dados alterados sempre serão capturados do ponto de verificação anterior da sua versão de pipeline selecionada.

Exemplo 1:

Ao encadear diretamente uma transformação de origem referenciada ao conjunto de dados habilitado para CDA do SQL com uma transformação de coletor referenciada a um banco de dados em um fluxo de dados de mapeamento, as alterações ocorridas na origem do SQL serão aplicadas automaticamente ao banco de dados de destino para que seja possível obter facilmente o cenário de replicação de dados entre bancos de dados. É possível usar o método de atualização na transformação do coletor para selecionar se você quer permitir inserção, permitir atualização ou permitir exclusão no banco de dados de destino. O script de exemplo no fluxo de dados de mapeamento é conforme abaixo.

source(output(
		id as integer,
		name as string
	),
	allowSchemaDrift: true,
	validateSchema: false,
	enableNativeCdc: true,
	netChanges: true,
	skipInitialLoad: false,
	isolationLevel: 'READ_UNCOMMITTED',
	format: 'table') ~> source1
source1 sink(allowSchemaDrift: true,
	validateSchema: false,
	deletable:true,
	insertable:true,
	updateable:true,
	upsertable:true,
	keys:['id'],
	format: 'table',
	skipDuplicateMapInputs: true,
	skipDuplicateMapOutputs: true,
	errorHandlingOption: 'stopOnFirstError') ~> sink1

Exemplo 2:

Se você quiser habilitar o cenário de ETL, em vez de replicação de dados entre banco de dados por meio de CDA do SQL, poderá usar expressões no fluxo de dados de mapeamento incluindo isInsert(1), isUpdate(1) e isDelete(1) para diferenciar as linhas com diferentes tipos de operação. A seguir é apresentado um dos scripts de exemplo para mapear o fluxo de dados ao derivar uma coluna com o valor: 1 para indicar as linhas inseridas, 2 para indicar as linhas atualizadas e 3 para indicar as linhas excluídas para transformações downstream para processar os dados delta.

source(output(
		id as integer,
		name as string
	),
	allowSchemaDrift: true,
	validateSchema: false,
	enableNativeCdc: true,
	netChanges: true,
	skipInitialLoad: false,
	isolationLevel: 'READ_UNCOMMITTED',
	format: 'table') ~> source1
source1 derive(operationType = iif(isInsert(1), 1, iif(isUpdate(1), 2, 3))) ~> derivedColumn1
derivedColumn1 sink(allowSchemaDrift: true,
	validateSchema: false,
	skipDuplicateMapInputs: true,
	skipDuplicateMapOutputs: true) ~> sink1

Limitação conhecida:

• Apenas as alterações líquidas da CDA do SQL serão carregadas pelo ADF por meio de cdc.fn_cdc_get_net_changes_.

Atualize a versão da Instância Gerenciada de SQL do Azure

Para atualizar a versão do Instância Gerenciada de SQL do Azure, na página Editar serviço vinculado, selecione Recomendado em Versão e configure o serviço vinculado, referindo-se às propriedades do serviço vinculado para a versão recomendada.

Diferenças entre a versão recomendada e a versão herdada

A tabela abaixo mostra as diferenças entre a Instância Gerenciada de SQL do Azure usando a versão recomendada e a versão herdada.

Conteúdo relacionado

Para obter uma lista dos armazenamentos de dados com suporte como coletores e fontes da atividade de cópia, confira os Armazenamentos de dados com suporte.