Eventos
Junte-se a nós na FabCon Vegas
31 de mar., 23 - 2 de abr., 23
O melhor evento liderado pela comunidade Microsoft Fabric, Power BI, SQL e AI. 31 de março a 2 de abril de 2025.
Registre-se hoje mesmoNão há mais suporte para esse navegador.
Atualize o Microsoft Edge para aproveitar os recursos, o suporte técnico e as atualizações de segurança mais recentes.
Aplica-se a: Banco de Dados SQL do Azure Instância Gerenciada de SQL do Azure
Este artigo descreve o uso de transações de banco de dados elástico que permitem executar transações distribuídas em bancos de dados de nuvem no Banco de Dados SQL do Azure e na Instância Gerenciada de SQL do Azure. Neste artigo, os termos "transações distribuídas" e "transações de banco de dados elástico" são considerados sinônimos e são usados de maneira intercambiável.
Observação
Use também o Coordenador de Transações Distribuídas para a Instância Gerenciada de SQL do Azure para executar transações distribuídas em ambientes mistos.
As transações de banco de dados elástico para o banco de dados SQL do Azure e a Instância Gerenciada de SQL do Azure permitem que você execute transações que abrangem vários bancos de dados. As transações de banco de dados elástico estão disponíveis para aplicativos .NET usando ADO .NET e se integram à experiência de programação conhecida usando as classes System.Transaction. Para obter a biblioteca, confira .NET Framework 4.6.1 (Web Installer). Além disso, para a Instância Gerenciada, transações distribuídas estão disponíveis no Transact-SQL.
No local, um cenário como esse geralmente exige a execução do MSDTC (Coordenador de Transações Distribuídas da Microsoft). Como o MSDTC não está disponível para o Banco de Dados SQL do Azure, a capacidade de coordenar as transações distribuídas foi diretamente integrada à Instância Gerenciada de SQL ou ao Banco de Dados SQL. No entanto, para a Instância Gerenciada de SQL, você também pode usar o Coordenador de Transações Distribuídas para executar transações distribuídas em vários ambientes mistos, como entre instâncias gerenciadas, SQL Servers, outros RDBMSs (sistemas de gerenciamento de banco de dados relacionais), aplicativos personalizados e outros participantes de transação hospedados em qualquer ambiente que possa estabelecer conectividade de rede com o Azure.
Os aplicativos podem se conectar a qualquer banco de dados para iniciar transações distribuídas, e um dos bancos de dados ou servidores coordenará de modo transparente a transação distribuída, como mostra a figura a seguir.
As transações de banco de dados elástico permitem que os aplicativos façam alterações atômicas nos dados armazenados em vários bancos de dados diferentes. Tanto o Banco de Dados SQL quanto a Instância Gerenciada de SQL oferecem suporte a experiências de desenvolvimento no lado do cliente em C# e .NET. A experiência do lado do servidor (código escrito em procedimentos armazenados ou scripts do lado do servidor) usando o Transact-SQL está disponível somente para a Instância Gerenciada de SQL.
Importante
Não há suporte para a execução de transações de banco de dado elástico entre o Banco de Dados SQL do Azure e a Instância Gerenciada de SQL do Azure. A transação de banco de dados elástico só pode abranger um conjunto de bancos de dados no Banco de Dados SQL ou um conjunto de bancos de dados entre instâncias gerenciadas.
As transações de banco de dados elástico têm como alvo os seguintes cenários:
As funcionalidades das transações de banco de dados elástico são fornecidas por meio de atualizações das bibliotecas .NET System.Data.dll e System.Transactions.dll. As DLLs garantem que o protocolo 2PC seja usado quando necessário para garantir a atomicidade. Para começar a desenvolver aplicativos usando as transações de banco de dados elástico, instale o .NET Framework 4.6.1 ou uma versão posterior. Quando executadas em uma versão anterior do .NET Framework, as transações não serão promovidas a uma transação distribuída, e uma exceção será gerada.
Após a instalação, você pode usar as APIs de transação distribuída em System.Transactions com conexões à Instância Gerenciada de SQL e ao Banco de Dados SQL. Se você já tiver aplicativos do MSDTC usando essas APIs, recompile os aplicativos existentes para o .NET 4.6 depois de instalar o .NET Framework 4.6.1. Se seus projetos tiverem como destino o .NET 4.6, eles usarão automaticamente as DLLs atualizadas da nova versão do Framework, e as chamadas à API de transação distribuída em conjunto com as conexões à Instância Gerenciada de SQL ou ao Banco de Dados SQL passarão a funcionar.
Lembre-se de que as transações de banco de dados elástico não requerem a instalação do MSDTC. Em vez disso, as transações de banco de dados elástico são gerenciadas diretamente pelo serviço, dentro dele. Isso simplifica significativamente os cenários de nuvem, já que a implantação de um MSDTC não é necessária para o uso das transações distribuídas com a Instância Gerenciada de SQL ou o Banco de Dados SQL. A Seção 4 explica detalhadamente como implantar as transações de banco de dados elástico e o .NET Framework necessário juntamente com seus aplicativos em nuvem no Azure.
O Azure fornece várias ofertas para hospedar aplicativos .NET. Uma comparação entre as diferentes ofertas está disponível em Comparação entre o Serviço de Aplicativo do Azure, os Serviços de Nuvem e as Máquinas Virtuais. Se o SO convidado da oferta for inferior ao .NET 4.6.1 exigido para transações elásticas, será necessário atualizar o SO para 4.6.1.
Para Serviço de Aplicativo do Azure, não há suporte para atualizações para o SO convidado no momento. Para as Máquinas virtuais do Azure, basta fazer logon na VM e executar o instalador do .NET Framework mais recente. Para os Serviços de Nuvem do Azure, você precisará incluir a instalação de uma versão mais recente do .NET em tarefas de inicialização da sua implantação. Os conceitos e as etapas estão documentados em Instalar o .NET em uma Função do Serviço de Nuvem.
Observe que o instalador do .NET 4.6.1 pode exigir mais armazenamento temporário durante o processo de inicialização nos Serviços de Nuvem do Azure que o instalador do .NET 4.6. Para garantir uma instalação bem-sucedida, você precisa aumentar o armazenamento temporário para o serviço de nuvem do Azure no seu arquivo ServiceDefinition.csdef na seção LocalResources e nas configurações do ambiente de sua tarefa de inicialização, conforme mostrado no exemplo a seguir:
<LocalResources>
...
<LocalStorage name="TEMP" sizeInMB="5000" cleanOnRoleRecycle="false" />
<LocalStorage name="TMP" sizeInMB="5000" cleanOnRoleRecycle="false" />
</LocalResources>
<Startup>
<Task commandLine="install.cmd" executionContext="elevated" taskType="simple">
<Environment>
...
<Variable name="TEMP">
<RoleInstanceValue xpath="/RoleEnvironment/CurrentInstance/LocalResources/LocalResource[@name='TEMP']/@path" />
</Variable>
<Variable name="TMP">
<RoleInstanceValue xpath="/RoleEnvironment/CurrentInstance/LocalResources/LocalResource[@name='TMP']/@path" />
</Variable>
</Environment>
</Task>
</Startup>
O exemplo de código a seguir usa a experiência de programação conhecida com o .NET System.Transactions. A classe TransactionScope estabelece uma transação de ambiente no .NET. (Uma "transação de ambiente" é aquela que reside no thread atual.) Todas as conexões abertas no TransactionScope participam da transação. Se diferentes bancos de dados participarem, a transação será elevada automaticamente a uma transação distribuída. O resultado da transação é controlado pela definição do escopo a concluir para indicar uma confirmação.
using (var scope = new TransactionScope())
{
using (var conn1 = new SqlConnection(connStrDb1))
{
conn1.Open();
SqlCommand cmd1 = conn1.CreateCommand();
cmd1.CommandText = string.Format("insert into T1 values(1)");
cmd1.ExecuteNonQuery();
}
using (var conn2 = new SqlConnection(connStrDb2))
{
conn2.Open();
var cmd2 = conn2.CreateCommand();
cmd2.CommandText = string.Format("insert into T2 values(2)");
cmd2.ExecuteNonQuery();
}
scope.Complete();
}
As transações de banco de dados elástico da Instância Gerenciada e do Banco de Dados SQL também oferecem suporte a coordenação de transações distribuídas, em que você usa o método OpenConnectionForKey da biblioteca do cliente de banco de dados elástico para abrir conexões para uma camada de dados escalados horizontalmente. Considere os casos em que você precisa garantir a consistência transacional das alterações em vários valores-chave de fragmentação diferentes. As conexões com os fragmentos que hospedam os diferentes valores-chave de fragmentação são intermediadas usando o OpenConnectionForKey. Em geral, as conexões podem ocorrer para diferentes fragmentos, de modo que para assegurar as garantias transacionais seja necessária uma transação distribuída. O exemplo de código a seguir ilustra essa abordagem. Ele pressupõe que uma variável chamada shardmap seja usada para representar um mapa do fragmento na biblioteca do cliente de banco de dados elástico:
using (var scope = new TransactionScope())
{
using (var conn1 = shardmap.OpenConnectionForKey(tenantId1, credentialsStr))
{
SqlCommand cmd1 = conn1.CreateCommand();
cmd1.CommandText = string.Format("insert into T1 values(1)");
cmd1.ExecuteNonQuery();
}
using (var conn2 = shardmap.OpenConnectionForKey(tenantId2, credentialsStr))
{
var cmd2 = conn2.CreateCommand();
cmd2.CommandText = string.Format("insert into T1 values(2)");
cmd2.ExecuteNonQuery();
}
scope.Complete();
}
As transações distribuídas no lado do servidor usando o Transact-SQL estão disponíveis somente para a Instância Gerenciada de SQL do Azure. A transação distribuída pode ser executada somente entre as instâncias que pertencem ao mesmo grupo de relação de confiança do servidor. Nesse cenário, as instâncias gerenciadas precisam usar o servidor vinculado para se referenciarem.
O código Transact-SQL de exemplo a seguir usa BEGIN DISTRIBUTED TRANSACTION para iniciar a transação distribuída.
-- Configure the Linked Server
-- Add one Azure SQL Managed Instance as Linked Server
EXEC sp_addlinkedserver
@server='RemoteServer', -- Linked server name
@srvproduct='',
@provider='MSOLEDBSQL', -- Microsoft OLE DB Driver for SQL Server
@datasrc='managed-instance-server.46e7afd5bc81.database.windows.net' -- SQL Managed Instance endpoint
-- Add credentials and options to this Linked Server
EXEC sp_addlinkedsrvlogin
@rmtsrvname = 'RemoteServer', -- Linked server name
@useself = 'false',
@rmtuser = '<login_name>', -- login
@rmtpassword = '<secure_password>' -- password
USE AdventureWorks2022;
GO
SET XACT_ABORT ON;
GO
BEGIN DISTRIBUTED TRANSACTION;
-- Delete candidate from local instance.
DELETE AdventureWorks2022.HumanResources.JobCandidate
WHERE JobCandidateID = 13;
-- Delete candidate from remote instance.
DELETE RemoteServer.AdventureWorks2022.HumanResources.JobCandidate
WHERE JobCandidateID = 13;
COMMIT TRANSACTION;
GO
Aplicativos .NET que usam classes System.Transaction podem combinar a classe TransactionScope com a instrução Transact-SQL BEGIN DISTRIBUTED TRANSACTION. No TransactionScope, a transação interna que executa a transação BEGIN DITRIBUTED TRANSACTION será explicitamente promovida para a transação distribuída. Além disso, quando a segunda SqlConnection for aberta dentro do TransactionScope, será promovida implicitamente para a transação distribuída. Depois que a transação distribuída for iniciada, todas as solicitações de transações subsequentes, sejam provenientes do .NET ou do Transact-SQL, ingressarão na transação distribuída pai. Como consequência, todos os escopos de transação aninhados iniciados pela instrução BEGIN terminarão na mesma transação e as instruções COMMIT/ROLLBACK terão o seguinte efeito sobre o resultado geral:
Aqui está um exemplo em que a transação é promovida explicitamente para a transação distribuída com Transact-SQL.
using (TransactionScope s = new TransactionScope())
{
using (SqlConnection conn = new SqlConnection(DB0_ConnectionString)
{
conn.Open();
// Transaction is here promoted to distributed by BEGIN statement
//
Helper.ExecuteNonQueryOnOpenConnection(conn, "BEGIN DISTRIBUTED TRAN");
// ...
}
using (SqlConnection conn2 = new SqlConnection(DB1_ConnectionString)
{
conn2.Open();
// ...
}
s.Complete();
}
O exemplo a seguir mostra uma transação que é promovida implicitamente para a transação distribuída depois que a segunda SqlConnection foi iniciada dentro do TransactionScope.
using (TransactionScope s = new TransactionScope())
{
using (SqlConnection conn = new SqlConnection(DB0_ConnectionString)
{
conn.Open();
// ...
}
using (SqlConnection conn = new SqlConnection(DB1_ConnectionString)
{
// Because this is second SqlConnection within TransactionScope transaction is here implicitly promoted distributed.
//
conn.Open();
Helper.ExecuteNonQueryOnOpenConnection(conn, "BEGIN DISTRIBUTED TRAN");
Helper.ExecuteNonQueryOnOpenConnection(conn, lsQuery);
// ...
}
s.Complete();
}
Há suporte para transações de Banco de Dados Elástico entre diferentes servidores no Banco de Dados SQL do Azure. Quando as transações cruzam os limites do servidor, os servidores participantes precisam primeiro serem inseridos em uma relação de comunicação comum. Após a relação de comunicação ser estabelecida, qualquer banco de dados em qualquer um dos dois servidores poderá participar de transações elásticas com bancos de dados do outro servidor. Com transações abrangendo mais de dois servidores, uma relação de comunicação deve estar em vigor para qualquer par de servidores.
Use os cmdlets do PowerShell a seguir para gerenciar as relações de comunicação entre servidores para transações de Banco de Dados Elástico:
As transações distribuídas têm suporte ao longo de bancos de dados em várias instâncias. Quando as transações cruzam os limites da instância gerenciada, as instâncias participantes precisam primeiro estar inseridas em uma relação de segurança e comunicação mútuas. Isso é feito criando-se um grupo de confiança do servidor, que pode ser feito usando o portal do Azure, o Azure PowerShell ou a CLI do Azure. Se as instâncias não estiverem na mesma rede virtual, o emparelhamento de rede virtual precisará ser configurado, e as regras de entrada e saída do grupo de segurança de rede precisarão permitir as portas 5024 e 11000-12000 em todas as redes virtuais participantes.
O diagrama a seguir mostra um grupo de confiança do servidor com instâncias gerenciadas que podem executar transações distribuídas com o .NET ou o Transact-SQL:
Use as DMVs (Exibições de Gerenciamento Dinâmico) para monitorar o status e o progresso das transações de banco de dados elástico em andamento. Todas as DMVs relacionadas a transações são relevantes para as transações distribuídas na Instância Gerenciada de SQL e no Banco de Dados SQL. Você pode encontrar a lista correspondente de DMVs aqui: Funções e exibições de gerenciamento dinâmico relacionadas a transações (Transact-SQL).
Estas DMVs são especialmente úteis:
As seguintes limitações se aplicam atualmente para as transações de banco de dados elástico no Banco de Dados SQL:
No momento, as seguintes limitações se aplicam a transações distribuídas (também conhecidas como transações elásticas ou transações distribuídas com suporte nativo) na Instância Gerenciada de SQL:
Eventos
Junte-se a nós na FabCon Vegas
31 de mar., 23 - 2 de abr., 23
O melhor evento liderado pela comunidade Microsoft Fabric, Power BI, SQL e AI. 31 de março a 2 de abril de 2025.
Registre-se hoje mesmoTreinamento
Certificação
Microsoft Certified: Azure Database Administrator Associate - Certifications
Administrar uma infraestrutura de banco de dados do SQL Server para bancos de dados relacionais de nuvem, locais e híbridos usando as ofertas de banco de dados relacional do Microsoft PaaS.