Elosztott tranzakciók több felhőalapú adatbázisban
A következőre vonatkozik:
Azure SQL DatabaseFelügyelt Azure SQL-példány
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 felügyelt Azure SQL-példány elosztott tranzakciókoordinátorával elosztott tranzakciókat is futtathat 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 system.transaction osztályokkal a jól ismert programozási felülettel. A kódtár beszerzéséhez tekintse meg a .NET-keretrendszer 4.6.1 -et (Web Installer). Felügyelt példányok esetében az elosztott tranzakciók a Transact-SQL-ben is elérhetők.
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. A felügyelt SQL-példányok esetében azonban az Elosztott tranzakciók koordinátorával is futtathat elosztott tranzakciókat számos vegyes környezetben, például felügyelt példányokon, SQL Servereken, más relációsadatbázis-kezelő rendszereken (RDBMS-ek), egyéni alkalmazásokon és bármely olyan környezetben üzemeltetett tranzakciós résztvevőkön, 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ó.
Common scenarios
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.
- Horizontálisan elosztott adatbázis-alkalmazások az Azure-ban: Ezzel a forgatókönyvvel az adatszint az Elastic Database ügyfélkódtárat vagy önszántolást használja az adatok horizontális particionálására az SQL Database vagy a felügyelt SQL-példány 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 például arra, hogy az egyik bérlőről a másikra történő átvitel különböző adatbázisokban található. A második eset a nagy bérlők kapacitásigényének kielégítése érdekében végzett részletes horizontális skálázás, amely általában azt jelenti, hogy egyes atomi műveleteknek több, ugyanazon bérlőhöz használt adatbázisra kell kiterjednie. A harmadik eset az adatbázisok között replikált adatokra mutató 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 képességei a System.Data.dll és a System.Transactions.dll .NET-kódtárak frissítésével érhetők el. 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 Azure-alkalmazás Szolgáltatás, Felhőszolgáltatások és Virtuális gépek ö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.
A Azure-alkalmazás szolgáltatás 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.
Vegye figyelembe, hogy 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 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.Transactions ismert programozási felületét használja. A TransactionScope osztály környezeti tranzakciót hoz létre a .NET-ben. (A "környezeti tranzakció" az aktuális szálon található.) A Tranzakcióhatókörben megnyitott összes 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 Open Csatlakozás ionForKey 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ő szegmenskulcs-értékeket üzemeltető szegmensekre Csatlakozás a rendszer az Open Csatlakozás ionForKey használatával közvetíti. Á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ételezi, hogy a rugalmas adatbázis ügyfélkódtárából származó szegmenstérképet egy szegmenstérképnek nevezett változó haszná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 élmény
A Transact-SQL-t használó kiszolgálóoldali elosztott tranzakciók 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 Transact-SQL-mintakód a BEGIN DISTRIBUTED TRANSACTION-t 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 a Transact-SQL fejlesztési élményének 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ó explicit módon elő lesz léptetve az elosztott tranzakcióra. Ha a második Sql Csatlakozás on meg van nyitva a TransactionScope-on belül, az implicit módon előlépteti az elosztott tranzakcióra. 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éptetett az elosztott tranzakcióra, miután a második Sql Csatlakozás on elindult a TransactionScopeban.
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
Az elosztott tranzakciók több példányon belüli adatbázisokban támogatottak. Ha a tranzakciók átlépik a felügyelt példány határait, a résztvevő példányoknak kölcsönös biztonsági és kommunikációs kapcsolatban kell állniuk egymással. 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.
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:
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ókért tekintse meg a DMV dokumentációját.
- 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ókért tekintse meg a DMV dokumentációját.
- 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ókért tekintse meg a DMV dokumentációját.
Korlátozások
Az SQL Database rugalmas adatbázis-tranzakcióira jelenleg a következő 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,például a BEGIN DISTRIBUTED TRANSACTION kiszolgálóoldali támogatása tervezett, de még nem érhető el.
- 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 SQL-példány elosztott tranzakcióira (más néven rugalmas tranzakciókra vagy natívan támogatott elosztott tranzakciókra) vonatkoznak:
- Ezzel a technológiával csak a felügyelt példányok adatbázisai közötti tranzakciók támogatottak. A felügyelt Azure SQL-példányon kívüli X/Open XA-erőforrás-szolgáltatókat és adatbázisokat tartalmazó egyéb forgatókönyvek esetében konfigurálnia kell a DTC-t a felügyelt Azure SQL-példányhoz.
- 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 felügyelt Azure SQL-példánynak egy kiszolgáló megbízhatósági csoportjának kell lennie ahhoz, hogy részt vehessen az elosztott tranzakcióban.
- A kiszolgálómegbízhatósági csoportok korlátozásai hatással vannak az elosztott tranzakciókra.
- Az elosztott tranzakciókban részt vevő felügyelt példányoknak privát végpontokon keresztüli kapcsolattal kell rendelkezniük (az üzembe helyezésük helye szerinti virtuális hálózat magánhálózati IP-címének használatával), és kölcsönösen hivatkozniuk kell rájuk privát teljes tartománynevek használatával. Az ügyfélalkalmazások elosztott tranzakciókat használhatnak privát végpontokon. Emellett azokban az esetekben, amikor a Transact-SQL privát végpontokra hivatkozó csatolt kiszolgálókat használ, az ügyfélalkalmazások elosztott tranzakciókat is használhatnak nyilvános végpontokon. Ezt a korlátozást az alábbi diagram ismerteti.
További lépések
- Kérdéseit az SQL Database Microsoft Q&A kérdésoldalán találhatja meg.
- Funkciókérések esetén adja hozzá őket az SQL Database visszajelzési fórumához vagy a felügyelt SQL-példány fórumához.