Dela via

Snabbstart: Distribuera ett SQL Server-containerkluster i Azure eller Red Hat OpenShift

gäller för:SQL Server – Linux

Den här snabbstarten visar hur du konfigurerar en SQL Server-instans med hög tillgänglighet i en container med beständig lagring, i Azure Kubernetes Service (AKS) eller Red Hat OpenShift. Om SQL Server-instansen misslyckas, återskapar orkestratorn den automatiskt i en ny pod. Klustertjänsten ger också återhämtning mot ett nodfel.

Den här snabbstarten använder följande kommandoradsverktyg för att hantera klustret.

Klustertjänsten Kommandoradsverktyg
Azure Kubernetes Service (AKS) kubectl (Kubernetes CLI)
Azure Red Hat OpenShift oc (OpenShift CLI)

Förutsättningar

Skapa ett SA-lösenord

Systemadministratörskontot (sa) måste skyddas med ett starkt lösenord. 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.

  1. Skapa ett sa lösenord i Kubernetes-klustret. Kubernetes kan hantera känslig konfigurationsinformation, till exempel lösenord som hemligheter.

  2. Om du vill skapa en hemlighet i Kubernetes med namnet mssql som innehåller värdet <password> för MSSQL_SA_PASSWORDkör du följande kommando. Ersätt <password> med ditt komplexa lösenord.

    Viktigt!

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

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

Skapa lagring

För en databas i ett Kubernetes-kluster måste du använda sparad lagring. Du kan konfigurera en beständig volym och ett beständigt volymanspråk i Kubernetes-klustret med hjälp av följande steg:

  1. Skapa ett manifest för att definiera lagringsklassen och det beständiga volymanspråket. Manifestet anger lagringsetableraren, parametrarna och återtagandeprincipen. Kubernetes-klustret använder det här manifestet för att skapa den beständiga lagringen.

  2. I följande YAML-exempel definieras en lagringsklass och beständiga volymanspråk. Etableringsverktyget för lagringsklassen är azure-disk, eftersom det här Kubernetes-klustret finns i Azure. Lagringskontotypen är Standard_LRS. Det beständiga volymkravet heter mssql-data. Beständiga metadata för volymanspråk innehåller en anteckning som ansluter tillbaka till lagringsklassen.

    kind: StorageClass
apiVersion: storage.k8s.io/v1
metadata:
     name: azure-disk
provisioner: kubernetes.io/azure-disk
parameters:
  storageaccounttype: Standard_LRS
  kind: Managed
---
kind: PersistentVolumeClaim
apiVersion: v1
metadata:
  name: mssql-data
  annotations:
    volume.beta.kubernetes.io/storage-class: azure-disk
spec:
  accessModes:
  - ReadWriteOnce
  resources:
    requests:
      storage: 8Gi

    Spara filen (till exempel pvc.yaml).

  3. Skapa PersistentVolumeClaim i Kubernetes, där <path to pvc.yaml file> är platsen där du sparade filen:

    kubectl apply -f <path to pvc.yaml file>

    Den beständiga volymen skapas automatiskt som ett Azure-lagringskonto och binds till det beständiga volymanspråket.

    storageclass "azure-disk" created
persistentvolumeclaim "mssql-data" created

  4. Verifiera Persistent Volume Claim, där <persistentVolumeClaim> är namnet på Persistent Volume Claim:

    kubectl describe pvc <persistentVolumeClaim>

    I föregående steg heter det beständiga volymanspråket mssql-data. För att se metadata om den beständiga volymanspråkningen kör följande kommando:

    kubectl describe pvc mssql-data

    De returnerade metadata innehåller ett värde som kallas Volume. Det här värdet mappar till blobens namn.

    Name:          mssql-data
Namespace:     default
StorageClass:  azure-disk
Status:        Bound
Volume:        pvc-d169b88e-f26d-11e7-bc3e-0a58ac1f09a4
Labels:        ‹none>
Annotations:   kubectl.kubernetes.io/last-applied-configuration-{"apiVersion":"v1","kind":"PersistentVolumeClaim","metadata":{"annotations":{"volume.beta.   kubernetes.io/storage-class":"azure-disk"},"name":"mssq1-data...
               pv.kubernetes.io/bind-completed-yes
               pv.kubernetes.io/bound-by-controller=yes
               volume.beta.kubernetes.io/storage-class=azure-disk
               volume.beta.kubernetes.io/storage-provisioner=kubernetes.io/azure-disk
Capacity:      8Gi
Access Modes:  RWO
Events:        <none>

    Värdet för volymen matchar en del av namnet på bloben i Azure-portalen.

  5. Kontrollera den ihållande volymen.

    kubectl describe pv

    kubectl returnerar metadata om den beständiga volymen som skapades automatiskt och har bundits till det beständiga volymkravet.

Skapa distributionen

Containern som är värd för SQL Server-instansen beskrivs som ett Kubernetes-distributionsobjekt. Distributionen skapar en replikuppsättning. Replikuppsättningen skapar podden.

Du skapar ett manifest för att beskriva containern, baserat på SQL Server mssql-server-linux Docker-avbildningen .

  • Manifestet refererar till det mssql-server beständiga volymanspråket och hemligheten mssql som du redan har tillämpat på Kubernetes-klustret.
  • Manifestet beskriver också en tjänst. Den här tjänsten är en lastbalanserare. Lastbalanseraren garanterar att IP-adressen bevaras när SQL Server-instansen har återställts.
  • Manifestet beskriver resursbegäranden och begränsningar. Dessa baseras på minimikraven för systemet.

  1. Skapa ett manifest (en YAML-fil) för att beskriva distributionen. I följande exempel beskrivs en distribution, inklusive en container baserat på SQL Server-containeravbildningen.

    apiVersion: apps/v1
kind: Deployment
metadata:
  name: mssql-deployment
spec:
  replicas: 1
  selector:
     matchLabels:
       app: mssql
  template:
    metadata:
      labels:
        app: mssql
    spec:
      terminationGracePeriodSeconds: 30
      hostname: mssqlinst
      securityContext:
        fsGroup: 10001
      containers:
      - name: mssql
        image: mcr.microsoft.com/mssql/server:2022-latest
        resources:
          requests:
            memory: "2G"
            cpu: "2000m"
          limits:
            memory: "2G"
            cpu: "2000m"
        ports:
        - containerPort: 1433
        env:
        - name: MSSQL_PID
          value: "Developer"
        - name: ACCEPT_EULA
          value: "Y"
        - name: MSSQL_SA_PASSWORD
          valueFrom:
            secretKeyRef:
              name: mssql
              key: MSSQL_SA_PASSWORD
        volumeMounts:
        - name: mssqldb
          mountPath: /var/opt/mssql
      volumes:
      - name: mssqldb
        persistentVolumeClaim:
          claimName: mssql-data
---
apiVersion: v1
kind: Service
metadata:
  name: mssql-deployment
spec:
  selector:
    app: mssql
  ports:
    - protocol: TCP
      port: 1433
      targetPort: 1433
  type: LoadBalancer

    Kopiera föregående kod till en ny fil med namnet sqldeployment.yaml. Uppdatera följande värden:

    • value: "Developer"MSSQL_PID : Anger att containern ska köra SQL Server Developer Edition. Utvecklarutgåvan är inte licensierad för produktionsdata. Om distributionen är för produktionsanvändning anger du lämplig utgåva (Enterprise, Standard, eller Express). Mer information finns i Så här licensierar du SQL Server.

    • persistentVolumeClaim: Det här värdet kräver en post för claimName: som mappar till namnet som används för det beständiga volymkravet. I den här handledningen används mssql-data.

    • name: MSSQL_SA_PASSWORD: Konfigurerar containeravbildningen sa för att ange lösenordet enligt definitionen i det här avsnittet.

      valueFrom:
  secretKeyRef:
    name: mssql
    key: MSSQL_SA_PASSWORD

      När Kubernetes distribuerar containern refererar den till hemligheten med namnet mssql för att hämta värdet för lösenordet.

    • securityContext: Definierar behörighets- och åtkomstkontrollinställningar för en podd eller container. I det här fallet anges den på poddnivå, så alla containrar följer den säkerhetskontexten. I säkerhetskontexten fsGroup definierar vi med värdet 10001, som är grupp-ID (GID) för mssql gruppen. Det här värdet innebär att alla processer i containern också ingår i den kompletterande GID:en 10001 (mssql). Ägaren för volymen /var/opt/mssql och alla filer som skapas på volymen är GID 10001 ( mssql gruppen).

    Varning

    Med hjälp av LoadBalancer tjänsttypen är SQL Server-instansen fjärransluten (via Internet) på port 1433.

    Spara filen. Till exempel sqldeployment.yaml.

  2. Skapa distributionen, där <path to sqldeployment.yaml file> är platsen där du sparade filen:

    kubectl apply -f <path to sqldeployment.yaml file>

    Distributionen och tjänsten skapas. SQL Server-instansen finns i en container som är ansluten till beständig lagring.

    deployment "mssql-deployment" created
service "mssql-deployment" created

    Distributionen och tjänsten skapas. SQL Server-instansen finns i en container som är ansluten till beständig lagring.

    Om du vill visa status för podden skriver du kubectl get pod.

    NAME                                READY    STATUS    RESTARTS   AGE
mssql-deployment-3813464711-h312s   1/1      Running   0          17m

    Podden har statusen Running. Den här statusen anger att containern är klar. När distributionen har skapats kan det ta några minuter innan podden visas. Fördröjningen beror på att klustret hämtar mssql-server-linux-avbildningen från Microsoft Artifact Registry. När avbildningen hämtas första gången kan efterföljande distributioner gå snabbare om distributionen är till en nod som redan har avbildningen cachelagrad.

  3. Kontrollera att tjänsterna körs. Kör följande kommando:

    kubectl get services

    Det här kommandot returnerar tjänster som körs och de interna och externa IP-adresserna för tjänsterna. Observera den externa IP-adressen för mssql-deployment tjänsten. Använd den här IP-adressen för att ansluta till SQL Server.

    NAME               TYPE           CLUSTER-IP    EXTERNAL-IP     PORT(S)          AGE
kubernetes         ClusterIP      10.0.0.1      <none>          443/TCP          52m
mssql-deployment   LoadBalancer   10.0.113.96   52.168.26.254   1433:30619/TCP   2m

    Kör följande kommando för mer information om status för objekten i Kubernetes-klustret. Kom ihåg att ersätta <MyResourceGroup> och <MyKubernetesClustername> med resursgruppen och Kubernetes-klusternamnet:

    az aks browse --resource-group <MyResourceGroup> --name <MyKubernetesClustername>

  4. Du kan också kontrollera att containern körs som icke-root genom att köra följande kommando, där <nameOfSqlPod> är namnet på SQL Server-podden:

    kubectl.exe exec <nameOfSqlPod> -it -- /bin/bash

    Du kan se användarnamnet som mssql om du kör whoami. mssql är en icke-rootanvändare.

    whoami

Ansluta till SQL Server-instansen

Du kan ansluta med ett program utanför det virtuella Azure-nätverket med hjälp av sa kontot och den externa IP-adressen för tjänsten. Använd lösenordet som du konfigurerade som OpenShift-hemligheten.

Du kan använda följande program för att ansluta till SQL Server-instansen.

Ansluta med sqlcmd

Kör följande kommando för att ansluta med sqlcmd.

sqlcmd -S <External IP address> -U sa -P "<password>"

Ersätt <External IP address> med IP-adressen för mssql-deployment tjänsten och <password> med ditt komplexa lösenord.

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.

Verifiera fel och återställning

För att verifiera fel och återställning kan du ta bort podden med följande steg:

  1. Visa en lista över podden som kör SQL Server.

    kubectl get pods

    Observera namnet på podden som kör SQL Server.

  2. Ta bort podden.

    kubectl delete pod mssql-deployment-0

    mssql-deployment-0 är värdet som returnerades från föregående steg för poddnamnet.

Kubernetes återskapar automatiskt podden för att återställa en SQL Server-instans och ansluter till den beständiga lagringen. Använd kubectl get pods för att kontrollera att en ny pod har distribuerats. Använd kubectl get services för att kontrollera att IP-adressen för den nya containern är densamma.

Rensa resurser

Om du inte planerar att gå igenom självstudierna som följer rensar du dina onödiga resurser. az group delete Använd kommandot för att ta bort resursgruppen, containertjänsten och alla relaterade resurser. Ersätt <MyResourceGroup> med namnet på resursgruppen som innehåller klustret.

az group delete --name <MyResourceGroup> --yes --no-wait

Relaterat innehåll