Använda distribuerade transaktioner med SQL Server Linux-containrar

Gäller för:SQL Server i Linux

Den här artikeln beskriver hur du konfigurerar SQL Server Linux-containrar för distribuerade transaktioner, inklusive särskilda krav och scenarier.

SQL Server-containeravbildningar kan använda Microsoft Distributed Transaction Coordinator (MSDTC), som krävs för distribuerade transaktioner. Information om kommunikationskraven för MSDTC finns i Konfigurera Microsoft Distributed Transaction Coordinator (MSDTC) på Linux.

Anteckning

SQL Server 2017 (14.x) körs som standard i rotcontainrar, medan SQL Server 2019 (15.x) och senare containrar körs som en icke-rotanvändare.

Konfiguration

Om du vill aktivera MSDTC-transaktioner i SQL Server-containrar måste du ange två nya miljövariabler:

• MSSQL_RPC_PORT: TCP-porten som RPC-slutpunktsmappningstjänsten binder till och lyssnar på.
• MSSQL_DTC_TCP_PORT: porten som MSDTC-tjänsten är konfigurerad för att lyssna på.

Dra och spring

I följande exempel visas hur du använder dessa miljövariabler för att hämta och köra en enda SQL Server 2019-container (15.x) som konfigurerats för MSDTC. På så sätt kan den kommunicera med alla program på alla värdar.

Viktig

Miljövariabeln SA_PASSWORD är inaktuell. Använd MSSQL_SA_PASSWORD i stället.

docker run \
   -e 'ACCEPT_EULA=Y' -e 'MSSQL_SA_PASSWORD=<password>' \
   -e 'MSSQL_RPC_PORT=135' -e 'MSSQL_DTC_TCP_PORT=51000' \
   -p 51433:1433 -p 135:135 -p 51000:51000  \
   -d mcr.microsoft.com/mssql/server:2019-GA-ubuntu-20.04

docker run `
   -e "ACCEPT_EULA=Y" -e "MSSQL_SA_PASSWORD=<password>" `
   -e "MSSQL_RPC_PORT=135" -e "MSSQL_DTC_TCP_PORT=51000" `
   -p 51433:1433 -p 135:135 -p 51000:51000  `
   -d mcr.microsoft.com/mssql/server:2019-GA-ubuntu-20.04

Försiktighet

Lösenordet bör följa SQL Server-standardprincipen för lösenord. Lösenordet måste som standard vara minst åtta tecken långt och innehålla tecken från tre av följande fyra uppsättningar: versaler, gemener, bas-10 siffror och symboler. Lösenord kan vara upp till 128 tecken långa. Använd lösenord som är så långa och komplexa som möjligt.

I det här kommandot är RPC Endpoint Mapper-tjänsten bunden till port 135, och tjänsten MSDTC är bunden till port 51000 i containerns virtuella nätverk. SQL Server TDS-kommunikation sker på port 1433, även i containerns virtuella nätverk. Dessa portar exponeras externt för värdmaskinen som TDS-port 51433, RPC-slutpunktsmappningsport 135 och MSDTC-port 51000.

RPC-slutpunktsmapparen och MSDTC-porten behöver inte vara samma på värden och containern. Så även om RPC Endpoint Mapper-porten har konfigurerats för att vara 135 på containern, kan den eventuellt mappas till port 13501 eller någon annan tillgänglig port på värdservern.

Konfigurera brandväggen

För att kunna kommunicera med och via värden måste du även konfigurera brandväggen på värdservern för containrarna. Öppna brandväggen för alla portar som SQL Server-containern exponerar för extern kommunikation. I föregående exempel skulle detta vara portarna 135, 51433 och 51000. Det här är portarna på själva värden och inte de portar som de mappar till i containern. Om RPC-slutpunktsmappningens port 51000 för containern har mappats till värdport 51001, bör port 51001 (inte 51000) öppnas i brandväggen för kommunikation med värden.

I följande exempel visas hur du skapar dessa regler på Ubuntu.

sudo ufw allow from any to any port 51433 proto tcp
sudo ufw allow from any to any port 51000 proto tcp
sudo ufw allow from any to any port 135 proto tcp

I följande exempel visas hur detta kan göras på Red Hat Enterprise Linux (RHEL):

sudo firewall-cmd --zone=public --add-port=51433/tcp --permanent
sudo firewall-cmd --zone=public --add-port=51000/tcp --permanent
sudo firewall-cmd --zone=public --add-port=135/tcp --permanent
sudo firewall-cmd --reload

Konfigurera portroutning på värddatorn

I föregående exempel, eftersom en enda SQL Server-container mappar RPC-port 135 till port 135 på värden, bör distribuerade transaktioner med värden nu fungera utan ytterligare konfiguration. Det går att använda port 135 direkt i containrar som körs som rot eftersom SQL Server körs med förhöjd behörighet i dessa containrar. För SQL Server utanför en container eller för icke-rotcontainrar måste du använda en annan tillfällig port (till exempel 13500) i containern, och trafik som är avsedd för port 135 måste sedan dirigeras till den porten. Du skulle också behöva konfigurera portroutningsregler i containern från containerport 135 till den tillfälliga porten.

Om du bestämmer dig för att mappa containerns port 135 till en annan port på värddatorn, till exempel 13500, måste du ställa in portdirigering på värddatorn. Detta gör att SQL Server-containern kan delta i distribuerade transaktioner med värden samt med andra externa servrar.

Mer information om routningsportar finns i Konfigurera portroutning.

SQL Server-containrar med MSDTC på Kubernetes

Om du distribuerar SQL Server-containrar på en Kubernetes-plattform kan du läsa följande exempel på YAML-distributionsmanifestet. I det här exemplet är Kubernetes-plattformen Azure Kubernetes Service (AKS).

Scenario 1: MSDTC-klient som ansluter till SQL Server i en Kubernetes-container

Följande diagram visar processen när en MSDTC-klient ansluter till MSDTC på SQL Server som körs i en Linux-container på Kubernetes.

1. MSDTC-klienten upprättar en anslutning till port 135 på Kubernetes-värden.
2. Anslutningen vidarebefordras till port 135 i containern.
3. Containern vidarebefordrar anslutningen till RPC-slutpunktsmapparen, som finns på port 13500 i det här exemplet.
4. Slutpunktsmapparen talar om för MSDTC-klienten vilken port MSDTC körs i containern (port 51000 i det här exemplet).
5. MSDTC-klienten upprättar en anslutning direkt till MSDTC genom att ansluta till värden på port 51000, vilken sedan vidarebefordras till SQL Server inuti containern.

Scenario 2: SQL Server ansluter till SQL Server i en Kubernetes-container

Följande diagram visar processen när en SQL Server Linux-container ansluter till MSDTC på en andra SQL Server Linux-container i Kubernetes.

1. Den första SQL Server-instansen upprättar en anslutning till port 135 på den Kubernetes-värd som tillhör den andra SQL Server-instansen.
2. Anslutningen vidarebefordras till port 135 i den andra instansens container.
3. Containern vidarebefordrar anslutningen till RPC-slutpunktsmapparen, som finns på port 13500 i det här exemplet.
4. Slutpunktsmapparen talar om för den första SQL Server-instansen vilken port MSDTC körs i den andra containern (port 51000 i det här exemplet).
5. Den första SQL Server-instansen upprättar en direkt anslutning till MSDTC på den andra instansen genom att ansluta till den andra värden på port 51000, vilket dirigeras vidare till SQL Server inuti containern.

Distribuera SQL Server-containrar med MSDTC konfigurerat på en Kubernetes-plattform

Innan du kör YAML-skriptet för exempeldistribution skapar du den hemlighet som krävs för att lagra sa lösenord med hjälp av följande exempelkommando:

kubectl create secret generic mssql --from-literal=MSSQL_SA_PASSWORD="<password>"

Försiktighet

Lösenordet bör följa SQL Server-standardprincipen för lösenord. Lösenordet måste som standard vara minst åtta tecken långt och innehålla tecken från tre av följande fyra uppsättningar: versaler, gemener, bas-10 siffror och symboler. Lösenord kan vara upp till 128 tecken långa. Använd lösenord som är så långa och komplexa som möjligt.

Du ser följande punkter i manifestfilen:

1. I klustret skapar vi följande objekt: StorageClass, två SQL Server-poddar som distribueras som statefulset-distributioner, och två lastbalansertjänster för att ansluta till respektive SQL Server-instanser.

2. Du märker också att lastbalanserarens tjänster distribueras med statiska IP-adresser som kan konfigureras i Azure Kubernetes Service. Se även Använda en statisk offentlig IP-adress och DNS-etikett med Azure Kubernetes Services (AKS) lastbalanserare. Om du skapar lastbalanserarens tjänster med statiska IP-adresser ser du till att den externa IP-adressen inte ändras om lastbalanserarens tjänst tas bort och återskapas.

3. I följande skript kan du se att port 13500 används för MSSQL_RPC_PORT miljövariabeln och port 51000 för miljövariabeln MSSQL_DTC_TCP_PORT, som båda krävs för MSDTC.

4. Portroutningen (d.v.s. routningsport 135 till 13500) konfigureras i lastbalanserarens skript genom att korrekt konfigurera port och targetPort enligt följande exempel:

kind: StorageClass
apiVersion: storage.k8s.io/v1
metadata:
     name: azure-disk
provisioner: kubernetes.io/azure-disk
parameters:
  storageaccounttype: Standard_LRS
  kind: Managed
---
apiVersion: apps/v1
kind: StatefulSet
metadata:
 name: mssql
 labels:
  app: mssql
spec:
 serviceName: "mssql"
 replicas: 2
 selector:
  matchLabels:
   app: mssql
 template:
  metadata:
   labels:
    app: mssql
  spec:
   securityContext:
     fsGroup: 10001
   containers:
   - name: mssql
     image: mcr.microsoft.com/mssql/server:2019-latest
     ports:
     - containerPort: 1433
       name: tcpsql
     - containerPort: 13500
       name: dtcport
     - containerPort: 51000
       name: dtctcpport
     env:
     - name: ACCEPT_EULA
       value: "Y"
     - name: MSSQL_ENABLE_HADR
       value: "1"
     - name: MSSQL_AGENT_ENABLED
       value: "1"
     - name: MSSQL_RPC_PORT
       value: "13500"
     - name: MSSQL_DTC_TCP_PORT
       value: "51000"
     - name: MSSQL_SA_PASSWORD
       valueFrom:
         secretKeyRef:
          name: mssql
          key: MSSQL_SA_PASSWORD
     volumeMounts:
     - name: mssql
       mountPath: "/var/opt/mssql"
 volumeClaimTemplates:
   - metadata:
      name: mssql
     spec:
      accessModes:
      - ReadWriteOnce
      resources:
       requests:
        storage: 8Gi
---
apiVersion: v1
kind: Service
metadata:
  name: mssql-0
spec:
  type: LoadBalancer
  loadBalancerIP: 10.88.213.209
  selector:
    statefulset.kubernetes.io/pod-name: mssql-0
  ports:
  - protocol: TCP
    port: 1433
    targetPort: 1433
    name: tcpsql
  - protocol: TCP
    port: 51000
    targetPort: 51000
    name: dtctcpport
  - protocol: TCP
    port: 135
    targetPort: 13500
    name: nonrootport
---
apiVersion: v1
kind: Service
metadata:
  name: mssql-1
spec:
  type: LoadBalancer
  loadBalancerIP: 10.72.137.129
  selector:
    statefulset.kubernetes.io/pod-name: mssql-1
  ports:
  - protocol: TCP
    port: 1433
    targetPort: 1433
    name: tcpsql
  - protocol: TCP
    port: 51000
    targetPort: 51000
    name: dtctcpport
  - protocol: TCP
    port: 135
    targetPort: 13500
    name: nonrootport

Om du har skapat resursen i standardnamnområdet bör du se utdata som visas i följande exempel när du kör kommandot kubectl get all efter föregående distribution för att se alla resurser som skapats.

NAME          READY   STATUS    RESTARTS   AGE
pod/mssql-0   1/1     Running   0          4d22h
pod/mssql-1   1/1     Running   0          4d22h

NAME                 TYPE           CLUSTER-IP    EXTERNAL-IP     PORT(S)                                        AGE
service/kubernetes   ClusterIP      10.0.0.1      <none>          443/TCP                                        6d6h
service/mssql-0      LoadBalancer   10.0.18.186   10.88.213.209   1433:31875/TCP,51000:31219/TCP,135:30044/TCP   2d6h
service/mssql-1      LoadBalancer   10.0.16.180   10.72.137.129   1433:30353/TCP,51000:32734/TCP,135:31239/TCP   2d6h

NAME                     READY   AGE
statefulset.apps/mssql   2/2     5d1h

Du kan använda verktyg som SQL Server Management Studio (SSMS) för att ansluta till någon av de två föregående SQL Server-instanserna och köra en DTC-exempeltransaktion. I det här exemplet ansluter du till mssql-1 (10.72.137.129) och skapar den länkade servern till mssql-0 (10.88.213.209) för att köra den distribuerade transaktionen, som du ser i följande exempel.

USE [master];
GO

EXECUTE master.dbo.sp_addlinkedserver
    @server = N'10.88.213.209',
    @srvproduct = N'SQL Server';
GO

EXECUTE master.dbo.sp_addlinkedsrvlogin
    @rmtsrvname = N'10.88.213.209',
    @rmtuser = 'sa',
    @rmtpassword = '<password>',
    @useself = N'False';
GO

Försiktighet

Lösenordet bör följa SQL Server-standardprincipen för lösenord. Lösenordet måste som standard vara minst åtta tecken långt och innehålla tecken från tre av följande fyra uppsättningar: versaler, gemener, bas-10 siffror och symboler. Lösenord kan vara upp till 128 tecken långa. Använd lösenord som är så långa och komplexa som möjligt.

Nu kan du starta den distribuerade transaktionen och det här kodexemplet visar sys.sysprocesses från mssql-0-instansen:

SET XACT_ABORT ON;

BEGIN DISTRIBUTED TRANSACTION;

SELECT *
FROM [10.88.213.209].master.dbo.sysprocesses;

COMMIT TRANSACTION;
GO

Relaterat innehåll

• Konfigurera Microsoft Distributed Transaction Coordinator (MSDTC) på Linux