Transakcje rozproszone w bazach danych w chmurze

Dotyczy:Azure SQL DatabaseAzure SQL Managed Instance

W tym artykule opisano używanie elastycznych transakcji bazy danych, które umożliwiają uruchamianie transakcji rozproszonych w bazach danych w chmurze dla usług Azure SQL Database i Azure SQL Managed Instance.

W tym artykule terminy "transakcje rozproszone" i "elastyczne transakcje bazy danych" są uznawane za synonimy i są używane zamiennie.

Uwaga

Można również użyć narzędzia Distributed Transaction Coordinator (DTC) dla usługi Azure SQL Managed Instance do uruchamiania transakcji rozproszonych w środowiskach mieszanych.

Omówienie

Elastyczne transakcje baz danych dla usług Azure SQL Database i Azure SQL Managed Instance umożliwiają uruchamianie transakcji obejmujących kilka baz danych. Elastyczne transakcje baz danych są dostępne dla aplikacji platformy .NET przy użyciu ADO.NET i integrują się ze znanym środowiskiem programowania przy użyciu klas System.Transaction . Aby uzyskać bibliotekę, zobacz .NET Framework 4.6.1 (Instalator sieci Web).

Ponadto w języku Transact-SQL dostępne są transakcje rozproszone dla zarządzanej instancji SQL.

W środowisku lokalnym taki scenariusz zwykle wymaga uruchomienia koordynatora transakcji rozproszonych firmy Microsoft (MSDTC). Ponieważ usługa MSDTC nie jest dostępna dla usługi Azure SQL Database, możliwość koordynowania transakcji rozproszonych została bezpośrednio zintegrowana z usługami SQL Database i SQL Managed Instance. Jednak w przypadku usługi SQL Managed Instance można także używać Distributed Transaction Coordinator (DTC) for Azure SQL Managed Instance do realizowania transakcji rozproszonych w wielu mieszanych środowiskach, na przykład między instancjami zarządzanymi, instancjami programu SQL Server, innymi relacyjnymi systemami zarządzania bazami danych (RDBMS), aplikacjami niestandardowymi oraz innymi uczestnikami transakcji hostowanymi w dowolnym środowisku, które może nawiązać łączność sieciową z platformą Azure.

Aplikacje mogą łączyć się z dowolną bazą danych w celu uruchomienia transakcji rozproszonych, a jedna z baz danych lub serwerów będzie w sposób niewidoczny koordynować transakcję rozproszoną, jak pokazano na poniższym rysunku.

Typowe scenariusze

Elastyczne transakcje bazy danych umożliwiają aplikacjom wprowadzanie niepodzielnych zmian w danych przechowywanych w kilku różnych bazach danych. Zarówno usługa SQL Database, jak i wystąpienie zarządzane SQL obsługują środowiska programistyczne po stronie klienta w językach C# i .NET. Środowisko po stronie serwera (kod napisany w procedurach składowanych lub skryptach po stronie serwera) przy użyciu języka Transact-SQL jest dostępne tylko dla usługi SQL Managed Instance.

Ważne

Uruchamianie transakcji elastycznej bazy danych między usługą Azure SQL Database i usługą Azure SQL Managed Instance nie jest obsługiwane. Transakcje elastycznej bazy danych mogą obejmować tylko zestaw baz danych w usłudze SQL Database lub zestaw baz danych w wystąpieniach zarządzanych.

Transakcje elastycznej bazy danych są przeznaczone dla następujących scenariuszy:

• Aplikacje z wieloma bazami danych na platformie Azure: w tym scenariuszu dane są partycjonowane pionowo w kilku bazach danych w usłudze SQL Database lub w wystąpieniu zarządzanym SQL, tak aby różne rodzaje danych znajdowały się w różnych bazach danych. Niektóre operacje wymagają zmian danych, które są przechowywane w co najmniej dwóch bazach danych. Aplikacja używa elastycznych transakcji bazy danych do koordynowania zmian w bazach danych i zapewnienia niepodzielności.
• Aplikacje baz danych podzielonych na fragmenty na platformie Azure: w tym scenariuszu warstwa danych używa biblioteki klienta Elastic Database client library lub mechanizmu samodzielnego fragmentowania w celu poziomego partycjonowania danych między wiele baz danych w usłudze SQL Database lub SQL Managed Instance. Jednym z widocznych przypadków użycia jest konieczność wykonania atomowych zmian w aplikacji wielodostępnej dzielonej na fragmenty, gdy zmiany obejmują najemców. Pomyśl na przykład o przeniesieniu z jednego dzierżawcy do drugiego, przy czym obaj znajdują się w różnych bazach danych. Drugi przypadek to shardowanie o drobnym stopniu podziału w celu zaspokojenia potrzeb pojemnościowych dużego dzierżawcy, co z kolei zwykle oznacza, że niektóre operacje atomowe muszą obejmować kilka baz danych używanych przez tego samego dzierżawcę. Trzeci przypadek to atomowe aktualizacje danych referencyjnych replikowanych między bazami danych. Niepodzielne, transakcyjne operacje wzdłuż tych linii można teraz koordynować w kilku bazach danych. Transakcje elastycznej bazy danych używają zatwierdzenia dwufazowego, aby zapewnić niepodzielność transakcji w bazach danych. Dobrze sprawdza się w przypadku transakcji obejmujących jednocześnie mniej niż 100 baz danych w ramach jednej transakcji. Te limity nie są wymuszane, ale należy oczekiwać, że wydajność i współczynniki powodzenia dla elastycznych transakcji bazy danych będą cierpieć w przypadku przekroczenia tych limitów.

Instalacja i migracja

Funkcje transakcji elastycznej bazy danych są udostępniane za pośrednictwem aktualizacji bibliotek platformy .NET System.Data.dll i System.Transactions.dll. Biblioteki DLL zapewniają, że tam, gdzie jest to konieczne, stosowany jest protokół dwufazowego zatwierdzania, aby zagwarantować atomowość. Aby rozpocząć tworzenie aplikacji przy użyciu transakcji elastycznej bazy danych, zainstaluj program .NET Framework 4.6.1 lub nowszą wersję. W przypadku uruchomienia we wcześniejszej wersji platformy .NET Framework nie będzie można przekształcić transakcji w transakcję rozproszoną i zostanie zgłoszony wyjątek.

Po instalacji możesz używać interfejsów API do transakcji rozproszonych w przestrzeni nazw System.Transactions przy użyciu połączeń do SQL Database i SQL Managed Instance. Jeśli masz istniejące aplikacje MSDTC korzystające z tych interfejsów API, ponownie skompiluj istniejące aplikacje dla platformy .NET 4.6 po zainstalowaniu programu Framework 4.6.1. Jeśli Twoje projekty są przeznaczone dla platformy .NET 4.6, będą automatycznie używać zaktualizowanych bibliotek DLL z nowej wersji platformy, a wywołania interfejsu API transakcji rozproszonych w połączeniu z połączeniami do usługi SQL Database lub wystąpienia SQL Managed Instance będą teraz kończyć się pomyślnie.

Pamiętaj, że transakcje elastycznych baz danych nie wymagają instalowania programu MSDTC. Zamiast tego elastyczne transakcje bazy danych są zarządzane bezpośrednio przez usługę i w ramach tej usługi. To znacznie upraszcza scenariusze chmurowe, ponieważ wdrożenie usługi MSDTC nie jest konieczne, aby korzystać z transakcji rozproszonych z usługą SQL Database lub usługą SQL Managed Instance. Sekcja 4 zawiera bardziej szczegółowe informacje na temat wdrażania elastycznych transakcji bazy danych i wymaganej platformy .NET Framework wraz z aplikacjami w chmurze na platformie Azure.

Instalacja platformy .NET dla usług Azure Cloud Services

Platforma Azure oferuje kilka ofert hostowania aplikacji platformy .NET. Porównanie różnych ofert jest dostępne w artykule Porównanie usług Azure App Service, Cloud Services i Virtual Machines. Jeśli system operacyjny gościa oferty jest mniejszy niż .NET 4.6.1 wymagany dla transakcji elastycznych, należy uaktualnić system operacyjny gościa do wersji 4.6.1.

W przypadku usługi Azure App Service uaktualnienia systemu operacyjnego gościa nie są obecnie obsługiwane. W przypadku usługi Azure Virtual Machines wystarczy zalogować się do maszyny wirtualnej i uruchomić instalatora najnowszej platformy .NET Framework. W przypadku usług Azure Cloud Services należy dołączyć instalację nowszej wersji platformy .NET do zadań uruchamiania wdrożenia. Pojęcia i kroki opisano w temacie Instalowanie platformy .NET w roli usługi w chmurze.

Instalator platformy .NET 4.6.1 może wymagać więcej magazynu tymczasowego podczas procesu uruchamiania w usługach w chmurze platformy Azure niż instalator dla platformy .NET 4.6. Aby zapewnić pomyślną instalację, należy zwiększyć pamięć tymczasową dla usługi w chmurze platformy Azure w sekcji LocalResources pliku ServiceDefinition.csdef oraz w ustawieniach środowiska zadania uruchamiania, jak przedstawiono w poniższym przykładzie:

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

Doświadczenie w programowaniu w .NET

Aplikacje z wieloma bazami danych

Poniższy przykładowy kod korzysta ze znanego środowiska programowania na platformie .NET System.Transactions. Klasa TransactionScope inicjuje transakcję środowiskową na platformie .NET. ("Transakcja środowiskowa" to taka, która znajduje się w bieżącym wątku.) Wszystkie połączenia otwarte w ramach TransactionScope uczestniczą w tej transakcji. Jeśli różne bazy danych uczestniczą, transakcja jest automatycznie podwyższona do transakcji rozproszonej. Wynik transakcji zależy od ustawienia zakresu na „complete”, co oznacza zatwierdzenie transakcji.

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

Aplikacje bazy danych podzielone na fragmenty

Elastyczne transakcje bazy danych dla usług SQL Database i SQL Managed Instance obsługują również koordynację transakcji rozproszonych, w przypadku których do otwierania połączeń dla warstwy danych skalowanej w poziomie używa się metody OpenConnectionForKey z biblioteki klienta elastycznej bazy danych. Rozważ przypadki, w których należy zagwarantować spójność transakcyjną zmian dotyczących kilku różnych wartości klucza fragmentowania. Połączenia z fragmentami obsługującymi różne wartości klucza fragmentowania są zestawiane przy użyciu metody OpenConnectionForKey. W ogólnym przypadku połączenia mogą być z różnymi fragmentami, dzięki czemu zapewnienie gwarancji transakcyjnych wymaga transakcji rozproszonej.

Poniższy przykładowy kod ilustruje to podejście. Zakłada się, że do reprezentowania mapy fragmentacji z biblioteki klienta elastycznej bazy danych jest używana zmienna o nazwie shardmap:

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

Doświadczenie w programowaniu w języku Transact-SQL

Transakcje rozproszone po stronie serwera przy użyciu języka Transact-SQL są dostępne tylko dla usługi Azure SQL Managed Instance. Transakcja rozproszona może być wykonywana tylko między wystąpieniami należącymi do tej samej grupy zaufania serwera. W tym scenariuszu wystąpienia zarządzane muszą używać serwera połączonego do odwoływania się do siebie nawzajem.

Poniższy przykładowy kod Języka Transact-SQL używa funkcji BEGIN DISTRIBUTED TRANSACTION do rozpoczęcia transakcji rozproszonej.

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

Łączenie środowiska programistycznego .NET i Transact-SQL

Aplikacje platformy .NET korzystające z klas System.Transaction mogą łączyć klasę TransactionScope z instrukcją Transact-SQL BEGIN DISTRIBUTED TRANSACTION. W obrębie TransactionScope transakcja wewnętrzna, która wykonuje polecenie BEGIN DISTRIBUTED TRANSACTION, zostanie jawnie awansowana do transakcji rozproszonej. Ponadto, gdy drugie połączenie SqlConnection zostanie otwarte w obrębie TransactionScope, zostanie ono niejawnie podniesione do transakcji rozproszonej. Po rozpoczęciu transakcji rozproszonej wszystkie kolejne żądania transakcyjne, niezależnie od tego, czy pochodzą z platformy .NET, czy z języka Transact-SQL, dołączą do nadrzędnej transakcji rozproszonej. W związku z tym wszystkie zagnieżdżone zakresy transakcji inicjowane przez instrukcję BEGIN zostaną uwzględnione w tej samej transakcji, a instrukcje COMMIT/ROLLBACK będą miały następujący wpływ na ogólny wynik:

• Instrukcja COMMIT nie będzie miała żadnego wpływu na zakres transakcji zainicjowany przez instrukcję BEGIN, czyli nie zostaną zatwierdzone żadne wyniki przed wywołania metody Complete() w obiekcie TransactionScope. Jeśli obiekt TransactionScope zostanie zniszczony przed zakończeniem, wszystkie zmiany wprowadzone w zakresie zostaną wycofane.
• Instrukcja ROLLBACK spowoduje wycofanie całego elementu TransactionScope. Wszelkie próby rejestracji nowych transakcji w TransactionScope zakończą się niepowodzeniem później, a także próba wywołania Complete() w obiekcie TransactionScope.

Oto przykład, w którym transakcja jest jawnie promowana do transakcji rozproszonej za pomocą języka 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();
}

W poniższym przykładzie pokazano transakcję, która jest niejawnie awansowana do transakcji rozproszonej, gdy tylko drugie połączenie SqlConnection zostanie uruchomione w ramach 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();
}

Transakcje dla usługi SQL Database

Transakcje elastycznej bazy danych są obsługiwane na różnych serwerach w usłudze Azure SQL Database. Gdy transakcje obejmują wiele serwerów, należy najpierw ustanowić wzajemną komunikację między uczestniczącymi serwerami. Po ustanowieniu relacji komunikacji każda baza danych na każdym z dwóch serwerów może uczestniczyć w elastycznych transakcjach z bazami danych z drugiego serwera. W przypadku transakcji obejmujących więcej niż dwa serwery między każdą parą serwerów musi istnieć połączenie komunikacyjne.

Użyj następujących poleceń cmdlet programu PowerShell, aby zarządzać relacjami komunikacji między serwerami dla elastycznych transakcji bazy danych:

• New-AzSqlServerCommunicationLink: użyj tego polecenia cmdlet, aby utworzyć nową relację komunikacji między dwoma serwerami w usłudze Azure SQL Database. Relacja jest symetryczna, co oznacza, że oba serwery mogą inicjować transakcje z innym serwerem.
• Get-AzSqlServerCommunicationLink: użyj tego polecenia cmdlet, aby pobrać istniejące relacje komunikacyjne i ich właściwości.
• Remove-AzSqlServerCommunicationLink: Użyj tego polecenia cmdlet, aby usunąć istniejącą relację komunikacyjną.

Transakcje dla usługi SQL Managed Instance

Transakcje rozproszone są obsługiwane w bazach danych w wielu wystąpieniach. Gdy transakcje przekraczają granice wystąpienia zarządzanego, wystąpienia uczestniczące muszą być we wzajemnej relacji zabezpieczeń i komunikacji. W tym celu należy utworzyć grupę zaufania serwera, którą można wykonać za pomocą witryny Azure Portal lub programu Azure PowerShell lub interfejsu wiersza polecenia platformy Azure. Jeśli instancje nie są w tej samej sieci wirtualnej, należy skonfigurować peering sieci wirtualnych, a reguły grupy zabezpieczeń sieci dla ruchu przychodzącego i wychodzącego muszą zezwalać na porty 5024 oraz 11000-12000 we wszystkich uczestniczących sieciach wirtualnych.

Na poniższym diagramie pokazano grupę Server Trust Group z wystąpieniami zarządzanymi, które mogą wykonywać transakcje rozproszone przy użyciu platformy .NET lub języka Transact-SQL:

Monitorowanie stanu transakcji

Użyj dynamicznych widoków zarządzania (DMV), aby monitorować stan i postęp bieżących elastycznych transakcji bazy danych. Wszystkie widoki dynamicznego zarządzania związane z transakcjami mają zastosowanie do transakcji rozproszonych w usługach SQL Database i SQL Managed Instance. Aby zapoznać się z odpowiednią listą widoków DMV, zobacz Dynamiczne widoki zarządzania i funkcje związane z transakcjami.

Te dynamiczne widoki zarządzania są szczególnie przydatne:

• sys.dm_tran_active_transactions: Wyświetla listę aktualnie aktywnych transakcji i ich stan. Kolumna UOW (Unit Of Work) umożliwia identyfikację różnych transakcji podrzędnych należących do tej samej transakcji rozproszonej. Wszystkie transakcje w ramach tej samej transakcji rozproszonej mają tę samą wartość UOW. Aby uzyskać więcej informacji, zobacz sys.dm_tran_active_transactions (Transact-SQL).
• sys.dm_tran_database_transactions: zawiera dodatkowe informacje o transakcjach, takie jak umieszczanie transakcji w dzienniku. Aby uzyskać więcej informacji, zobacz sys.dm_tran_database_transactions (Transact-SQL).
• sys.dm_tran_locks: zawiera informacje o blokadach, które są obecnie utrzymywane przez bieżące transakcje. Aby uzyskać więcej informacji, zobacz sys.dm_tran_locks (Transact-SQL).

Ograniczenia

Następujące ograniczenia dotyczą obecnie transakcji elastycznych baz danych w usłudze Azure SQL Database:

• Obsługiwane są tylko transakcje w bazach danych w usłudze SQL Database. Inni dostawcy zasobów X/Open XA i bazy danych spoza usługi SQL Database nie mogą uczestniczyć w transakcjach elastycznych baz danych. Oznacza to, że elastyczne transakcje baz danych nie mogą rozciągać się na lokalny program SQL Server i usługę Azure SQL Database. W przypadku transakcji rozproszonych lokalnie nadal używaj usługi MSDTC.
• Obsługiwane są tylko transakcje koordynowane przez klienta z aplikacji .NET. Obsługa języka T-SQL po stronie serwera, taka jak BEGIN DISTRIBUTED TRANSACTION jest planowana, ale nie jest jeszcze dostępna.
• Transakcje w usługach WCF nie są obsługiwane. Na przykład masz metodę usługi WCF, która wykonuje transakcję. Objęcie wywołania zakresem transakcji spowoduje błąd System.ServiceModel.ProtocolException.

Następujące ograniczenia dotyczą obecnie transakcji rozproszonych (nazywanych również elastycznymi transakcjami lub natywnie obsługiwanymi transakcjami rozproszonymi) w usłudze Azure SQL Managed Instance:

• Dzięki tej technologii obsługiwane są tylko transakcje między bazami danych w wystąpieniach zarządzanych. W przypadku wszystkich innych scenariuszy, które mogą obejmować dostawców zasobów X/Open XA oraz bazy danych znajdujące się poza usługą Azure SQL Managed Instance, należy skonfigurować Koordynatora Transakcji Rozproszonych (DTC) dla usługi Azure SQL Managed Instance.
• Transakcje w usługach WCF nie są obsługiwane. Na przykład masz metodę usługi WCF, która wykonuje transakcję. Objęcie wywołania zakresem transakcji spowoduje błąd System.ServiceModel.ProtocolException.
• Usługa Azure SQL Managed Instance musi należeć do grupy zaufania serwera , aby móc uczestniczyć w transakcji rozproszonej.
• Ograniczenia grupy zaufania serwera mają wpływ na transakcje rozproszone.
• Wystąpienia zarządzane, które uczestniczą w transakcjach rozproszonych, muszą mieć łączność za pośrednictwem prywatnych punktów końcowych (przy użyciu prywatnego adresu IP z sieci wirtualnej, w której są wdrożone) i muszą być wzajemnie przywoływane przy użyciu prywatnych w pełni kwalifikowanych nazw domen (FQDN). Aplikacje klienckie mogą używać transakcji rozproszonych w prywatnych punktach końcowych. Ponadto w przypadkach, gdy język Transact-SQL korzysta z serwerów połączonych odwołujące się do prywatnych punktów końcowych, aplikacje klienckie mogą również używać transakcji rozproszonych w publicznych punktach końcowych. To ograniczenie zostało wyjaśnione na poniższym diagramie.

Treści powiązane

• Usługa Azure Private Link dla usług Azure SQL Database i Azure Synapse Analytics
• Koordynator transakcji rozproszonych (DTC) dla usługi Azure SQL Managed Instance
• Samouczek: implementowanie rozproszonej geograficznie bazy danych (Azure SQL Database)