Megosztás a következőn keresztül:

Elosztott tranzakciók felhőbeli adatbázisok között

A következőkre vonatkozik:Azure SQL DatabaseAzure SQL Managed Instance

Ez a cikk rugalmas adatbázistranzakciók használatát ismerteti, amelyek lehetővé teszik elosztott tranzakciók futtatását felhőbeli adatbázisok között az Azure SQL Database-hez és a felügyelt Azure SQL-példányhoz.

Ebben a cikkben az "elosztott tranzakciók" és a "rugalmas adatbázis-tranzakciók" kifejezések szinonimáknak minősülnek, és felcserélhetők.

Megjegyzés:

A Azure SQL Felügyelt Példány Elosztott Tranzakció Koordinátorát (DTC) is használhatja elosztott tranzakciók futtatására vegyes környezetekben.

Áttekintés

Az Azure SQL Database és a felügyelt Azure SQL-példány rugalmas adatbázistranzakciói lehetővé teszik több adatbázisra kiterjedő tranzakciók futtatását. A rugalmas adatbázistranzakciók a .NET-alkalmazások számára érhetők el ADO.NET használatával, és integrálhatók a jól ismert programozási felülettel a System.Transaction osztályok használatával. A kódtár beszerzéséhez lásd: .NET Framework 4.6.1 (Web Installer).

Emellett a felügyelt SQL-példányok elosztott tranzakciói elérhetők a Transact-SQL-ben.

A helyszíni esethez általában a Microsoft Distributed Transaction Coordinator (MSDTC) futtatása szükséges. Mivel az MSDTC nem érhető el az Azure SQL Database-hez, az elosztott tranzakciók koordinálásának lehetősége közvetlenül integrálva lett az SQL Database-be és a felügyelt SQL-példányba. Felügyelt SQL-példány esetén azonban az Azure SQL Managed Instance elosztott tranzakciókoordinátorával (DTC) is futtathat elosztott tranzakciókat számos vegyes környezetben, például felügyelt példányokon, SQL-kiszolgálókon, más relációsadatbázis-kezelő rendszereken (RDBMS-ek), egyéni alkalmazásokon és bármely olyan környezetben üzemeltetett tranzakció résztvevőin, amelyek hálózati kapcsolatot létesíthetnek az Azure-ral.

Az alkalmazások bármely adatbázishoz csatlakozhatnak az elosztott tranzakciók elindításához, és az egyik adatbázis vagy kiszolgáló transzparens módon koordinálja az elosztott tranzakciót, ahogy az az alábbi ábrán látható.

Az Azure SQL Database-rel rugalmas adatbázistranzakciókat használó elosztott tranzakciók diagramja.

Gyakori forgatókönyvek

A rugalmas adatbázis-tranzakciók lehetővé teszik az alkalmazások számára, hogy atomi módosításokat végezzenek a különböző adatbázisokban tárolt adatokon. Az SQL Database és a felügyelt SQL-példány egyaránt támogatja a C# és a .NET ügyféloldali fejlesztési élményét. A Transact-SQL-t használó kiszolgálóoldali felület (tárolt eljárásokban vagy kiszolgálóoldali szkriptekben írt kód) csak felügyelt SQL-példányokhoz érhető el.

Fontos

Az Azure SQL Database és az Azure SQL Managed Instance közötti rugalmas adatbázis-tranzakciók futtatása nem támogatott. A rugalmas adatbázistranzakció csak az SQL Database-ben lévő adatbázisokra vagy a felügyelt példányok egy meghatározott adatbázisára terjedhet ki.

A rugalmas adatbázis-tranzakciók a következő forgatókönyveket célják:

  • Többadatbázisos alkalmazások az Azure-ban: Ezzel a forgatókönyvvel az adatok vertikálisan particionálva vannak az SQL Database vagy a felügyelt SQL-példány több adatbázisában, így különböző típusú adatok találhatók különböző adatbázisokban. Egyes műveletek az adatok módosítását igénylik, amelyek két vagy több adatbázisban vannak tárolva. Az alkalmazás rugalmas adatbázis-tranzakciókat használ a változások adatbázisok közötti koordinálásához és az atomiság biztosításához.
  • Adatbázis-alkalmazások horizontális elosztása az Azure-ban: Ezzel a forgatókönyvvel az adatszint az Elastic Database ügyfélkódtárat vagy önshardingot használja az adatok horizontális particionálására az SQL adatbázis vagy a felügyelt SQL-példányok számos adatbázisában. Az egyik kiemelt használati eset az, ha atomi módosításokat kell végrehajtani a több-bérlős szegmenses alkalmazásokban, amikor a módosítások a bérlőkre terjednek ki. Gondoljon arra, amikor az egyik bérlő adatait egy másik bérlőnek továbbítják, mindkettő különböző adatbázison helyezkedik el. A második eset a részletes adatbázis-felosztás, amelynek célja egy nagy bérlő kapacitásigényeinek kielégítése, ami gyakran azt jelenti, hogy egyes atomi műveleteknek több, ugyanazon bérlő által használt adatbázisra kell kiterjedniük. A harmadik eset az adatbázisok között replikált referenciaadatokon végrehajtott atomi frissítések. Az ezen vonalak mentén végrehajtott atomi, átjátszott műveletek mostantól több adatbázison is koordinálhatók. A rugalmas adatbázis-tranzakciók két fázisú véglegesítéssel biztosítják a tranzakciók atomiságát az adatbázisok között. Jó választás olyan tranzakciókhoz, amelyek egyszerre kevesebb mint 100 adatbázist foglalnak magukban egyetlen tranzakción belül. Ezeket a korlátokat nem kényszerítjük ki, de a rugalmas adatbázis-tranzakciók teljesítmény- és sikerességi rátája várhatóan meg fog szenvedni, ha túllépi ezeket a korlátokat.

Telepítés és migrálás

A rugalmas adatbázis-tranzakciók funkcióit a .NET-kódtárak System.Data.dll és System.Transactions.dllfrissítései biztosítják. A DLL-ek biztosítják, hogy szükség esetén a kétfázisú véglegesítést használják az atomitás biztosításához. Ha rugalmas adatbázis-tranzakciók használatával szeretne alkalmazásokat fejleszteni, telepítse a .NET-keretrendszer 4.6.1-es vagy újabb verzióját. Ha a .NET-keretrendszer egy korábbi verzióján fut, a tranzakciók nem lesznek előléptetve egy elosztott tranzakcióra, és kivétel lép fel.

A telepítés után használhatja az elosztott tranzakciós API-kat a System.Transactions-ben, az SQL Database-hez és a felügyelt SQL-példányhoz való kapcsolódással. Ha meglévő MSDTC-alkalmazásokkal rendelkezik ezekkel az API-kkal, a 4.6.1-keretrendszer telepítése után újraépítheti a .NET 4.6-hoz készült meglévő alkalmazásokat. Ha a projektek a .NET 4.6-ot célozzák, a rendszer automatikusan az új keretrendszerverzió frissített DLL-jeit fogja használni, és az elosztott tranzakciós API-hívások az SQL Database-hez vagy a felügyelt SQL-példányhoz való csatlakozással együtt sikeresek lesznek.

Ne feledje, hogy a rugalmas adatbázis-tranzakciókhoz nincs szükség az MSDTC telepítésére. Ehelyett a rugalmas adatbázistranzakciókat közvetlenül a szolgáltatás kezeli, illetve azon belül. Ez jelentősen leegyszerűsíti a felhőalapú forgatókönyveket, mivel az MSDTC üzembe helyezése nem szükséges elosztott tranzakciók sql database-sel vagy felügyelt SQL-példányokkal való használatához. A 4. szakasz részletesebben ismerteti, hogyan helyezhet üzembe rugalmas adatbázis-tranzakciókat és a szükséges .NET-keretrendszert a felhőalapú alkalmazásokkal együtt az Azure-ban.

.NET-telepítés az Azure Cloud Serviceshez

Az Azure számos ajánlatot kínál .NET-alkalmazások üzemeltetésére. A különböző ajánlatok összehasonlítása az Azure App Service, a Cloud Services és a Virtual Machines összehasonlításában érhető el. Ha az ajánlat vendég operációs rendszere kisebb, mint a rugalmas tranzakciókhoz szükséges .NET 4.6.1, a vendég operációs rendszert 4.6.1-re kell frissítenie.

Az Azure App Service esetében a vendég operációs rendszerre való frissítés jelenleg nem támogatott. Azure Virtual Machines esetén egyszerűen jelentkezzen be a virtuális gépre, és futtassa a telepítőt a legújabb .NET-keretrendszerhez. Az Azure Cloud Services esetében egy újabb .NET-verzió telepítését kell belefoglalnia az üzembe helyezés indítási feladataiba. A fogalmakat és a lépéseket a .NET telepítése egy felhőszolgáltatás-szerepkörben dokumentálja.

A .NET 4.6.1 telepítője több ideiglenes tárterületet igényelhet az Azure-felhőszolgáltatások rendszerindítási folyamata során, mint a .NET 4.6 telepítője. A sikeres telepítés biztosításához növelnie kell az Azure cloud service ideiglenes tárterületét a ServiceDefinition.csdef fájlban a LocalResources szakaszban, valamint az indítási feladat környezeti beállításait, ahogyan az alábbi példában látható:

<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 fejlesztési tapasztalat

Többadatbázisos alkalmazások

Az alábbi mintakód a .NET System.Transactionsismert programozási felületét használja. Az TransactionScope osztály környezeti tranzakciót hoz létre a .NET-ben. ("A "környezeti tranzakció" az aktuális szálban fut.) Minden TransactionScope keretein belül megnyitott kapcsolat részt vesz a tranzakcióban. Ha különböző adatbázisok vesznek részt, a tranzakció automatikusan elosztott tranzakcióra emelkedik. A tranzakció kimenetét a befejezési hatókör beállításával vezérli a véglegesítés jelzésére.

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

Horizontális adatbázis-alkalmazások

Az SQL Database és a felügyelt SQL-példány rugalmas adatbázistranzakciói támogatják az elosztott tranzakciók koordinálását is, ahol a rugalmas adatbázis-ügyfélkódtár OpenConnectionForKey metódusával nyithat kapcsolatokat egy kibővített adatszinthez. Fontolja meg azokat az eseteket, amikor a tranzakciós konzisztenciát több különböző skálázási kulcsérték változásaihoz kell garantálnia. A különböző horizontális skálázási kulcsértékeket üzemeltető szegmensekkel való kapcsolatok az OpenConnectionForKey használatával vannak közvetítve. Általános esetben a kapcsolatok különböző szegmensekhez is kapcsolódhatnak, így a tranzakciós garanciák biztosítása elosztott tranzakciót igényel.

Az alábbi kódminta ezt a megközelítést szemlélteti. Feltételezhető, hogy a shardmap nevű változó a rugalmas adatbázis ügyfélkönyvtárából származó szegmenstérképet reprezentálja.

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 fejlesztési tapasztalat

A kiszolgálóoldali elosztott tranzakciók Transact-SQL használatával csak felügyelt Azure SQL-példányokhoz érhetők el. Az elosztott tranzakció csak olyan példányok között hajtható végre, amelyek ugyanahhoz a kiszolgálómegbízhatósági csoporthoz tartoznak. Ebben a forgatókönyvben a felügyelt példányoknak társított kiszolgálót kell használniuk egymásra való hivatkozáshoz.

Az alábbi minta Transact-SQL kód a BEGIN DISTRIBUTED TRANSACTION függvényt használja az elosztott tranzakció elindításához.

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

A .NET és Transact-SQL fejlesztési élmény kombinálása

A System.Transaction osztályokat használó .NET-alkalmazások kombinálhatják a TransactionScope osztályt a Transact-SQL utasítással, a BEGIN DISTRIBUTED TRANSACTION utasítással. A TransactionScope-on belül a BEGIN ELOSZTOTT TRANZAKCIÓt végrehajtó belső tranzakció kifejezetten elosztott tranzakcióvá válik. Ezenkívül, ha a második SqlConnection megnyílik a TransactionScope-on belül, az implicit módon elosztott tranzakcióvá alakul át. Az elosztott tranzakció elindítása után az összes további tranzakciókérés , függetlenül attól, hogy .NET-ről vagy Transact-SQL-ről származnak-e, csatlakozik a szülő elosztott tranzakcióhoz. Ennek következtében a BEGIN utasítás által kezdeményezett összes beágyazott tranzakciós hatókör ugyanabba a tranzakcióba kerül, és a COMMIT/ROLLBACK utasítások a következő hatással lesznek a teljes eredményre:

  • A COMMIT utasítás semmilyen hatással nem lesz a BEGIN utasítás által kezdeményezett tranzakciós hatókörre, azaz a Complete() metódus TransactionScope objektumon való meghívása előtt nem lesz véglegesítve eredmény. Ha a TransactionScope objektum a befejezés előtt megsemmisül, a hatókörön belüli összes módosítás vissza lesz állítva.
  • A ROLLBACK utasítás a teljes TransactionScope visszaállítását eredményezi. A TransactionScope-on belüli új tranzakciókra tett kísérletek később sikertelenek lesznek, valamint a Complete() meghívása a TransactionScope objektumon.

Íme egy példa, amelyben a tranzakció explicit módon előléptethető a Transact-SQL-sel rendelkező elosztott tranzakcióra.

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

Az alábbi példa egy olyan tranzakciót mutat be, amely implicit módon előléptethető az elosztott tranzakcióra, miután a második SqlConnection elindult a TransactionScope-ban.

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

Az SQL Database tranzakciói

A rugalmas adatbázis-tranzakciók az Azure SQL Database különböző kiszolgálóiban támogatottak. Amikor a tranzakciók átlépik a kiszolgáló határait, a részt vevő kiszolgálókat először kölcsönös kommunikációs kapcsolatba kell helyezni. A kommunikációs kapcsolat létrejötte után a két kiszolgáló bármelyik adatbázisa részt vehet a másik kiszolgáló adatbázisaival folytatott rugalmas tranzakciókban. Ha a tranzakciók kétnál több kiszolgálóra terjednek ki, kommunikációs kapcsolatot kell létesíteni minden kiszolgálópár esetében.

A rugalmas adatbázis-tranzakciók kiszolgálóközi kommunikációs kapcsolatainak kezeléséhez használja az alábbi PowerShell-parancsmagokat:

  • New-AzSqlServerCommunicationLink: Ezzel a parancsmaggal új kommunikációs kapcsolatot hozhat létre két kiszolgáló között az Azure SQL Database-ben. A kapcsolat szimmetrikus, ami azt jelenti, hogy mindkét kiszolgáló kezdeményezhet tranzakciókat a másik kiszolgálóval.
  • Get-AzSqlServerCommunicationLink: Ezzel a parancsmaggal lekérheti a meglévő kommunikációs kapcsolatokat és azok tulajdonságait.
  • Remove-AzSqlServerCommunicationLink: Ezzel a parancsmaggal eltávolíthat egy meglévő kommunikációs kapcsolatot.

Felügyelt SQL-példány tranzakciói

Több példányon belüli adatbázisok esetében az elosztott tranzakciók támogatottak. Ha a tranzakciók átlépik a felügyelt példányok határait, a részt vevő példányoknak kölcsönös biztonsági és kommunikációs kapcsolatban kell lenniük. Ez egy kiszolgálómegbízhatósági csoport létrehozásával történik, amely az Azure Portal, az Azure PowerShell vagy az Azure CLI használatával végezhető el. Ha a példányok nem ugyanazon a virtuális hálózaton találhatók, akkor konfigurálnia kell a virtuális hálózatok közötti társviszony-létesítést és a hálózati biztonsági csoport bejövő és kimenő szabályait, hogy engedélyezve legyen az 5024-11000-12000 port az összes részt vevő virtuális hálózaton.

Képernyőkép a felügyelt Azure SQL-példány SQL-megbízhatósági csoportjairól az Azure Portalon.

Az alábbi ábra egy felügyelt példányokkal rendelkező kiszolgálómegbízhatósági csoportot mutat be, amely elosztott tranzakciókat hajthat végre .NET-tel vagy Transact-SQL-sel:

Diagram az elosztott tranzakciókról az Azure SQL Felügyelt Példány használatával rugalmas tranzakciókhoz.

Tranzakció állapotának figyelése

Dinamikus felügyeleti nézetek (DMV-k) használatával monitorozhatja a folyamatban lévő rugalmas adatbázis-tranzakciók állapotát és előrehaladását. A tranzakciókhoz kapcsolódó összes DMV releváns az SQL Database-ben és a felügyelt SQL-példányban lévő elosztott tranzakciókhoz. A DMV-k megfelelő listáját itt találja: Tranzakcióval kapcsolatos dinamikus felügyeleti nézetek és függvények (Transact-SQL).

Ezek a DMV-k különösen hasznosak:

  • sys.dm_tran_active_transactions: Felsorolja az aktuálisan aktív tranzakciókat és azok állapotát. Az UOW (Unit Of Work) oszlop azonosítja azokat a gyermektranzakciókat, amelyek ugyanahhoz az elosztott tranzakcióhoz tartoznak. Az ugyanazon elosztott tranzakción belüli összes tranzakció ugyanazt az UOW-értéket hordozza. További információ: sys.dm_tran_active_transactions (Transact-SQL).
  • sys.dm_tran_database_transactions: További információkat nyújt a tranzakciókról, például a tranzakciónak a naplóban való elhelyezéséről. További információ: sys.dm_tran_database_transactions (Transact-SQL).
  • sys.dm_tran_locks: Információt nyújt a folyamatban lévő tranzakciók által jelenleg tárolt zárolásokról. További információ: sys.dm_tran_locks (Transact-SQL).

Korlátozások

Az Azure SQL Database rugalmas adatbázis-tranzakcióira jelenleg az alábbi korlátozások vonatkoznak:

  • Az SQL Database-ben csak az adatbázisok közötti tranzakciók támogatottak. Más X/Open XA erőforrás-szolgáltatók és az SQL Database-en kívüli adatbázisok nem vehetnek részt rugalmas adatbázis-tranzakciókban. Ez azt jelenti, hogy a rugalmas adatbázis-tranzakciók nem nyúlhatnak át a helyszíni SQL Server és az Azure SQL Database között. A helyszíni elosztott tranzakciók esetében továbbra is használja az MSDTC-t.
  • Csak a .NET-alkalmazások ügyfél által koordinált tranzakciói támogatottak. A T-SQL kiszolgálóoldali támogatása tervezés alatt áll, de még nem érhető el, mint ahogyan a BEGIN DISTRIBUTED TRANSACTION esetében is.
  • A WCF-szolgáltatások közötti tranzakciók nem támogatottak. Van például egy WCF szolgáltatás metódusa, amely végrehajt egy tranzakciót. A hívás tranzakciós hatókörbe való beágyazása System.ServiceModel.ProtocolException hibaként meghiúsul.

A következő korlátozások jelenleg a felügyelt Azure SQL-példány elosztott tranzakcióira (más néven rugalmas tranzakciókra vagy natívan támogatott elosztott tranzakciókra) vonatkoznak:

Egy privát végpont kapcsolati hálózatának és korlátainak diagramja.

Kapcsolódó tartalom

  • Last updated on