Distribuerade transaktioner mellan molndatabaser (förhandsversion)

GÄLLER FÖR: Azure SQL Database i Azure SQL Hanterad instans

Viktigt

Distribuerade transaktioner för Azure SQL Hanterad instans är nu allmänt tillgängliga. Transaktioner av databasdatabaser av Azure SQL Database är i förhandsversion.

Transaktioner av databasdatabaser av Azure SQL Database (förhandsversion) och Azure SQL hanterade instanser gör att du kan köra transaktioner som spänner över flera databaser. Transaktioner av databaserna av elasticitet är tillgängliga för .NET-program med ADO.NET och integreras med den välbekanta programmeringsupplevelsen med hjälp av system.transaction-kurserna. Information om hur du hämtar biblioteket .NET Framework 4.6.1 (webbinstallationsprogram). För hanterade instanser är distribuerade transaktioner dessutom tillgängliga i Transact-SQL.

Lokalt kräver ett sådant scenario vanligtvis att microsoft distribuerade transaktionsroller (MSDTC) körs. Eftersom MSDTC inte är tillgängligt för programmet Platform-as-a-Service i Azure har nu möjligheten att koordinera distribuerade transaktioner direkt integrerats i SQL Database eller SQL Managed Instance. Program kan ansluta till valfri databas för att starta distribuerade transaktioner och en av databaserna eller servrarna koordinerar transparent den distribuerade transaktionen, enligt följande bild.

I det här dokumentet anses "distribuerade transaktioner" och "databastransaktioner av databaser" vara synonymer och kommer att användas på ett annat sätt.

Distributed transactions with Azure SQL Database using elastic database transactions

Vanliga scenarier

Transaktioner med databasdatabaser av databasdatabaser gör det möjligt att göra atomiska ändringar i data som lagras i flera olika databaser. Både SQL Database och SQL hanterade instansen har stöd för utveckling av klientsidan i C# och .NET. En serverupplevelse (kod som skrivits i lagrade procedurer eller serverbaserade skript) med Transact-SQL är endast tillgänglig SQL Hanterad instans.

Viktigt

Det går inte att köra transaktioner med en azure Azure SQL Database databas mellan SQL och Azure SQL inte. Databastransaktionen av en databas och SQL Database en uppsättning databaser över hanterade instanser.

Transaktioner av databasdatabaser av databasdatabaser av databasdatabaser som är av följande mål:

  • Flerdatabasprogram i Azure: Med det här scenariot partitioneras data lodrätt mellan flera databaser i SQL Database eller SQL hanterade instanser så att olika typer av data finns i olika databaser. Vissa åtgärder kräver ändringar av data, som sparas i två eller fler databaser. Programmet använder databastransaktioner av dåen för att koordinera ändringarna över databaser och säkerställa atomitet.
  • Fragmenterade databasprogram i Azure: Med det här scenariot använder datanivån klientbiblioteket elasticitetdatabasen eller fragmentering för att vågrätt partitionera data över många databaser i SQL Database eller SQL hanterad instans. Ett framträdande användningsfall är behovet av att utföra atomiska ändringar för ett fragmenterat program för flera klientorganisationen när ändringar gäller flera innehavare. Tänk efter en överföring från en klientorganisation till en annan, som båda finns i olika databaser. Ett andra fall är finkornig sharding för att tillgodose kapacitetsbehoven för en stor klientorganisation, vilket i sin tur i sin tur antyder att vissa atomiska åtgärder måste sträckas över flera databaser som används för samma klientorganisation. Ett tredje fall är atomiska uppdateringar för referensdata som replikeras över databaser. Atomiska, transakterade, operationer längs dessa linjer kan nu koordineras över flera databaser. Transaktioner av databaserna av en databas med två faser används för att säkerställa att transaktionens atomitet ligger över databaser. Det passar bra för transaktioner som involverar färre än 100 databaser samtidigt inom en enskild transaktion. De här begränsningarna tillämpas inte, men du kan förvänta dig prestanda och framgångshastigheter för transaktioner med databaser av elasticitet som drabbas av att de överskrider dessa gränser.

Installation och migrering

Funktionerna för databastransaktioner av elasticitet tillhandahålls via uppdateringar av .NET-biblioteken System.Data.dll och System.Transactions.dll. DLL-filer säkerställer att tvåfas-commit används där det behövs för att säkerställa atomitet. Installera .NET Framework 4.6.1 eller en senare version för att börja utveckla program med transaktioner med en elasticitetdatabas. När transaktioner körs på en tidigare version av .NET Framework går det inte att marknadsföra en distribuerad transaktion och ett undantag kommer att upphöjas.

Efter installationen kan du använda de distribuerade transaktions-API:erna i System.Transactions med anslutningar SQL Database och SQL Hanterad instans. Om du har befintliga MSDTC-program med hjälp av de här API:erna återskapar du de befintliga programmen för .NET 4.6 när du har installerat 4.6.1 Framework. Om projekten har .NET 4.6 som mål används automatiskt de uppdaterade DLL-filer från den nya Framework-versionen och API-anrop för distribuerade transaktioner i kombination med anslutningar till SQL Database eller SQL Managed Instance.

Kom ihåg att transaktioner med en elasticitetdatabas inte kräver installation av MSDTC. I stället hanteras transaktioner av en elasticitetdatabas direkt av och inom tjänsten. Detta förenklar avsevärt molnscenarier eftersom en distribution av MSDTC inte är nödvändig för att använda distribuerade transaktioner med SQL Database eller SQL Hanterad instans. I avsnitt 4 förklaras mer i detalj hur du distribuerar databastransaktioner av en elasticitet och det nödvändiga .NET-ramverket tillsammans med dina molnprogram till Azure.

.NET-installation för Azure Cloud Services

Azure tillhandahåller flera produkter som värd för .NET-program. En jämförelse av de olika erbjudandena finns i jämförelsen av Azure-apptjänster, molntjänster och virtuella maskiner. Om gäst-operativsystemet för erbjudandet är mindre än .NET 4.6.1 som krävs för elasticitettransaktioner måste du uppgradera gäst-OS till 4.6.1.

För Azure App Service stöds inte uppgraderingar av gästoperativsystem. För virtuella Azure-datorer loggar du bara in på den virtuella datorn och kör installationsprogrammet för det senaste .NET Framework. För Azure Cloud Services måste du inkludera installationen av en nyare .NET-version i startuppgifterna för distributionen. Begreppen och stegen beskrivs i Installera .NET på en molntjänstroll.

Observera att installationsprogrammet för .NET 4.6.1 kan kräva mer tillfällig lagring under startprocessen i Azure-molntjänster än installationsprogrammet för .NET 4.6. För att installationen ska lyckas måste du öka den temporära lagringen för Azure-molntjänsten i filen ServiceDefinition.csdef i avsnittet LocalResources och miljöinställningarna för startaktiviteten, enligt följande exempel:

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

.NET-utvecklingsupplevelse

Flerdatabasprogram

I följande exempelkod används den välbekanta programmeringsupplevelsen med .NET System.Transactions. Klassen TransactionScope upprättar en omgivande transaktion i .NET. (En "omgivande transaktion" är en som finns i den aktuella tråden.) Alla anslutningar som öppnas i TransactionScope ingår i transaktionen. Om olika databaser ingår, upphöjs transaktionen automatiskt till en distribuerad transaktion. Resultatet av transaktionen kontrolleras genom att ange att omfattningen är slutförd för att ange ett åtagande.

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();
}

Fragmenterade databasprogram

Transaktioner av databasdatabaser av databasarfetr av SQL Database och SQL Hanterad instans har också stöd för koordinerade distribuerade transaktioner där du använder metoden OpenConnectionForKey för databasdatabasens klientbibliotek för att öppna anslutningar för en skalad datanivå. Överväg fall där du behöver garantera transaktionskonsekvens för ändringar på flera olika fragmenterande nyckelvärden. Anslutningar till de fragmenterade som är värd för de olika nyckelvärdena för fragmentering förmedlas via OpenConnectionForKey. I allmänhet kan anslutningarna vara till olika fragmenter så att du kan säkerställa att transaktionsgarantier kräver en distribuerad transaktion. Följande kodexempel illustrerar den här metoden. Den förutsätter att en variabel som kallas shardmap används för att representera en fragmentsk karta från klientbiblioteket för databaser med fragmenter:

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();
}

Transact-SQL för utveckling

En serverbaserade distribuerade transaktioner med Transact-SQL är endast tillgängliga för Azure SQL Managed Instance. Distribuerad transaktion kan endast utföras mellan hanterade instanser som tillhör samma serverförtroendegrupp. I det här scenariot måste hanterade instanser använda länkade servrar för att referera till varandra.

Följande exempel på Transact-SQL använder BEGIN DISTRIBUTED TRANSACTION för att starta en distribuerad transaktion.

    -- Configure the Linked Server
    -- Add one Azure SQL Managed Instance as Linked Server
    EXEC sp_addlinkedserver
        @server='RemoteServer', -- Linked server name
        @srvproduct='',
        @provider='sqlncli', -- SQL Server Native Client
        @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 AdventureWorks2012;
    GO
    SET XACT_ABORT ON;
    GO
    BEGIN DISTRIBUTED TRANSACTION;
    -- Delete candidate from local instance.
    DELETE AdventureWorks2012.HumanResources.JobCandidate
        WHERE JobCandidateID = 13;
    -- Delete candidate from remote instance.
    DELETE RemoteServer.AdventureWorks2012.HumanResources.JobCandidate
        WHERE JobCandidateID = 13;
    COMMIT TRANSACTION;
    GO

Kombinerar .NET och Transact-SQL utvecklingsupplevelse

.NET-program som använder System.Transaction-klasser kan kombinera klassen TransactionScope med Transact-SQL-satsen BEGIN DISTRIBUTED TRANSACTION. Inom TransactionScope framhävs inre transaktion som kör BEGIN DISTRIBUTED TRANSACTION uttryckligen till distribuerad transaktion. När andra SqlConnecton öppnas i TransactionScope framhävs detta implicit till en distribuerad transaktion. När den distribuerade transaktionen har startats kommer alla efterföljande transaktionsförfrågningar, oavsett om de kommer från .NET eller SQL, koppla ihop den överordnade distribuerade transaktionen. Eftersom alla kapslade transaktionsomfattningar initierade av BEGIN-satsen är oanvända kommer dessa uttryck att hamna i samma transaktion och COMMIT/ROLLBACK-uttryck har följande effekt på det övergripande resultatet:

  • COMMIT-instruktionen påverkar inte transaktionsomfattningen initierad av BEGIN-uttrycket, det vill säga att inga resultat kommer att genomföras innan metoden Complete() anropas för TransactionScope-objektet. Om TransactionScope-objektet förstörs innan det slutförs återställs alla ändringar som gjorts inom omfattningen.
  • ROLLBACK-satsen gör att hela TransactionScope återställs. Alla försök att lista nya transaktioner i TransactionScope misslyckas efteråt, samt försök att anropa Complete() på TransactionScope-objekt.

Här är ett exempel där transaktionen uttryckligen framhävs till en distribuerad transaktion med 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();
}

I följande exempel visas en transaktion som implicit framhävs till en distribuerad transaktion när den andra SqlConnecton startades i 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();
}

Transaktioner för SQL Database

Viktigt

Distribuerade transaktioner för Azure SQL Database är i förhandsversion.

Transaktioner till databaserna av en databas av en elasticitet stöds över olika servrar i Azure SQL Database. När transaktioner går över servergränser måste de servrar som deltar först anges i en gemensam kommunikationsrelation. När kommunikationsrelationen har upprättats kan alla databaser på någon av de två servrarna delta i elasticitettransaktioner med databaser från den andra servern. För transaktioner som sträcker sig över fler än två servrar måste en kommunikationsrelation finnas för alla par servrar.

Använd följande PowerShell-cmdlets för att hantera kommunikationsrelationer mellan servrar för transaktioner i en elasticitetdatabas:

  • New-AzSqlServerCommunicationLink: Använd den här cmdleten för att skapa en ny kommunikationsrelation mellan två servrar i Azure SQL Database. Relationen är symmetrisk, vilket betyder att båda servrarna kan initiera transaktioner med den andra servern.
  • Get-AzSqlServerCommunicationLink: Använd den här cmdleten för att hämta befintliga kommunikationsrelationer och deras egenskaper.
  • Remove-AzSqlServerCommunicationLink: Använd den här cmdleten för att ta bort en befintlig kommunikationsrelation.

Transaktioner för SQL hanterad instans

Viktigt

Distribuerade transaktioner för Azure SQL Hanterad instans är nu allmänt tillgängliga.

Distribuerade transaktioner stöds i databaser inom flera instanser. När transaktioner korsar gränser för hanterade instanser måste de deltagande instanserna finnas i en gemensam säkerhets- och kommunikationsrelation. Detta görs genom att skapa en serverförtroendegruppsom kan göras med hjälp av Azure-portalen eller Azure PowerShell eller Azure CLI. Om instanser inte finns i samma virtuella nätverk måste du tillåta portarna 5024 och 11000-12000 i alla deltagande virtuella nätverk om instanserna inte finns i samma virtuella nätverk.

Server Trust Groups on Azure Portal

I följande diagram visas en serverförtroendegrupp med hanterade instanser som kan köra distribuerade transaktioner med .NET eller SQL:

Distributed transactions with Azure SQL Managed Instance using elastic transactions

Övervaka transaktionsstatus

Du kan använda DMV-vyer (Dynamic Management Views) för att övervaka status och förloppet för dina pågående transaktioner i databaser. Alla DMVs som är relaterade till transaktioner är relevanta för distribuerade transaktioner i SQL Database och SQL hanterade instans. Du hittar motsvarande lista över DMV här: Transaktionsrelaterade vyer och funktioner för dynamisk hantering (Transact-SQL).

Dessa DMV-apparater är särskilt användbara:

  • sys.dm_tran_active_transactions: Visar aktuella aktiva transaktioner och deras status. Kolumnen UOW (Unit of Work) kan identifiera olika underordnade transaktioner som hör till samma distribuerade transaktion. Alla transaktioner inom samma distribuerade transaktion har samma UOW-värde. Mer information finns i DMV-dokumentationen.
  • sys.dm_tran_database_transactions:Ger ytterligare information om transaktioner, till exempel placeringen av transaktionen i loggen. Mer information finns i DMV-dokumentationen.
  • sys.dm_tran_locks:Ger information om de lås som för närvarande hålls av pågående transaktioner. Mer information finns i DMV-dokumentationen.

Begränsningar

Följande begränsningar gäller för närvarande på transaktioner i databasdatabasen av en elasticitet i SQL Database:

  • Endast transaktioner mellan databaser i SQL Database stöds. Andra X/Öppna XA-resursleverantörer och -databaser SQL Database kan inte delta i transaktioner i databasdatabasen. Det innebär att transaktioner med en elasticitetdatabas inte kan sträcka sig över den lokala SQL Server och Azure SQL Database. För lokala transaktioner fortsätter du att använda MSDTC.
  • Endast klient-koordinerade transaktioner från ett .NET-program stöds. Stöd på serversidan för T-SQL, till exempel BEGIN DISTRIBUTED TRANSACTION, är planerat, men är inte tillgängligt ännu.
  • Transaktioner mellan WCF-tjänster stöds inte. Du har till exempel en WCF-tjänstmetod som kör en transaktion. Att omsluta samtalet inom en transaktionsomfattning misslyckas som ett System.ServiceModel.ProtocolException.

Följande begränsningar gäller för närvarande för distribuerade transaktioner i SQL hanterade instanser:

  • Endast transaktioner mellan databaser i hanterade instanser stöds. Andra X/Öppna XA-resursleverantörer och -databaser utanför Azure SQL Hanterade instanser kan inte delta i distribuerade transaktioner. Det innebär att distribuerade transaktioner inte kan sträcka sig över lokala lokala SQL Server och Azure SQL Managed Instance. För lokala transaktioner fortsätter du att använda MSDTC.
  • Transaktioner mellan WCF-tjänster stöds inte. Du har till exempel en WCF-tjänstmetod som kör en transaktion. Att omsluta samtalet inom en transaktionsomfattning misslyckas som ett System.ServiceModel.ProtocolException.
  • Azure SQL Hanterad instans måste vara en del av en serverförtroendegrupp för att kunna delta i distribuerade transaktioner.
  • Begränsningar i Server-förtroendegrupper påverkar distribuerade transaktioner.
  • Hanterade instanser som deltar i distribuerade transaktioner måste ha anslutning via privata slutpunkter (med privat IP-adress från det virtuella nätverket där de distribueras) och måste refereras till ömsesidigt med privata FQDN. Klientprogram kan använda distribuerade transaktioner på privata slutpunkter. I fall där Transact-SQL utnyttjar länkade servrar som refererar till privata slutpunkter kan klientprogram även använda distribuerade transaktioner på offentliga slutpunkter. Den här begränsningen förklaras i följande diagram.

Private endpoint connectivity limitation

Nästa steg