Delen via

Quickstart: Een SQL Server-containercluster implementeren in Azure of Red Hat OpenShift

van toepassing op:SQL Server- - Linux

In deze quickstart ziet u hoe u een maximaal beschikbaar SQL Server-exemplaar configureert in een container met permanente opslag, in Azure Kubernetes Service (AKS) of Red Hat OpenShift. Als het SQL Server-exemplaar mislukt, maakt de orchestrator deze automatisch opnieuw in een nieuwe pod. De clusterservice biedt ook tolerantie tegen een knooppuntfout.

In deze quickstart worden de volgende opdrachtregelprogramma's gebruikt om het cluster te beheren.

Clusterservice Opdrachtregelprogramma
Azure Kubernetes Service (AKS) kubectl (Kubernetes CLI)
Azure Red Hat OpenShift oc (OpenShift CLI)

Vereiste voorwaarden

  • Een Azure-account met een actief abonnement. Gratis een account maken

  • Een Kubernetes-cluster. Zie kubectl voor meer informatie over het maken van en verbinden met een Kubernetes-cluster in AKS.

    Opmerking

    Ter bescherming tegen storingen in een knooppunt heeft een Kubernetes-cluster meer dan één knooppunt nodig.

  • Azure CLI. Zie Hoe u de Azure CLI installeert om de nieuwste versie te installeren.

Een SA-wachtwoord maken

Het account van de systeembeheerder (sa) moet worden beveiligd met een sterk wachtwoord. Uw wachtwoord moet voldoen aan het standaard SQL Server-wachtwoordbeleid . Standaard moet het wachtwoord ten minste acht tekens lang zijn en tekens bevatten uit drie van de volgende vier sets: hoofdletters, kleine letters, basis-10 cijfers en symbolen. Wachtwoorden mogen maximaal 128 tekens lang zijn. Gebruik wachtwoorden die zo lang en complex mogelijk zijn.

  1. Maak een sa wachtwoord in het Kubernetes-cluster. Kubernetes kan gevoelige configuratie-informatie, zoals wachtwoorden, beheren als geheimen.

  2. Om een secret in Kubernetes aan te maken met de naam mssql die de waarde <password> voor de MSSQL_SA_PASSWORD bevat, voert u de volgende opdracht uit. Vervang <password> door uw complexe wachtwoord.

    Belangrijk

    De omgevingsvariabele SA_PASSWORD is afgeschaft. Gebruik in plaats daarvan MSSQL_SA_PASSWORD.

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

Opslag maken

Voor een database in een Kubernetes-cluster moet u permanente opslag gebruiken. U kunt een permanent volume en permanente volumeclaim configureren in het Kubernetes-cluster met behulp van de volgende stappen:

  1. Maak een manifest om de opslagklasse en de permanente volumeclaim te definiëren. In het manifest worden de opslagvoorziener, parameters en terugvorderingsbeleid gespecificeerd. Het Kubernetes-cluster gebruikt dit manifest voor het maken van de permanente opslag.

  2. In het volgende YAML-voorbeeld wordt een opslagklasse en permanente volumeclaim gedefinieerd. De opslagklasse-provisioner is azure-disk, omdat dit Kubernetes-cluster zich in Azure bevindt. Het type opslagaccount is Standard_LRS. De naam van de permanente volumeclaim is mssql-data. De metagegevens van de permanente volumeclaim bevatten een aantekening dat het koppelt aan de opslagklasse.

    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

    Sla het bestand op (bijvoorbeeld pvc.yaml).

  3. Maak de permanente volumeclaim in Kubernetes, waar <path to pvc.yaml file> bevindt zich de locatie waar u het bestand hebt opgeslagen:

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

    Het permanente volume wordt automatisch gemaakt als een Azure Storage-account en is gebonden aan de permanente volumeclaim.

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

  4. Controleer de permanente volumeclaim, waar <persistentVolumeClaim> is de naam van de permanente volumeclaim:

    kubectl describe pvc <persistentVolumeClaim>

    In de vorige stap heeft de permanente volumeclaim de naam mssql-data. Voer de volgende opdracht uit om de metagegevens van de permanente volumeclaim te bekijken:

    kubectl describe pvc mssql-data

    De geretourneerde metagegevens bevatten een waarde met de naam Volume. Deze waarde komt overeen met de naam van de blob.

    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>

    De waarde voor het volume komt overeen met een deel van de naam van de blob in Azure Portal.

  5. Controleer het permanente volume.

    kubectl describe pv

    kubectl retourneert metagegevens over het permanente volume dat automatisch is gemaakt en is gebonden aan de permanente volumeclaim.

De implementatie maken

De container die als host fungeert voor het SQL Server-exemplaar, wordt beschreven als een Kubernetes-implementatieobject. Met de implementatie wordt een replicaset gemaakt. De replicaset maakt de pod.

U maakt een manifest om de container te beschrijven, gebaseerd op de SQL Server mssql-server-linux Docker-image.

  • Het manifest verwijst naar de mssql-server-permanente volumeclaim en het mssql-geheim dat u al hebt toegepast op het Kubernetes-cluster.
  • In het manifest wordt ook een servicebeschreven. Deze service is een load-balancer. De load balancer garandeert dat het IP-adres blijft bestaan nadat het SQL Server-exemplaar is hersteld.
  • In het manifest worden resourceaanvragen en -limieten beschreven. Deze zijn gebaseerd op de minimale systeemvereisten.

  1. Maak een manifest (een YAML-bestand) om de implementatie te beschrijven. In het volgende voorbeeld wordt een implementatie beschreven, inclusief een container op basis van de SQL Server-containerinstallatiekopieën.

    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

    Kopieer de voorgaande code naar een nieuw bestand met de naam sqldeployment.yaml. Werk de volgende waarden bij:

    • value: "Developer"MSSQL_PID: hiermee stelt u de container in om de SQL Server Developer-editie uit te voeren. Developer Edition heeft geen licentie voor productiegegevens. Als de implementatie voor productiegebruik is, stelt u de juiste editie in (Enterprise, Standard, of Express). Zie SQL Server licentie geven voor meer informatie.

    • persistentVolumeClaim: Deze waarde vereist een invoer voor claimName: die overeenkomt met de naam die wordt gebruikt voor de persistent volume claim. In deze zelfstudie wordt mssql-data gebruikt.

    • name: MSSQL_SA_PASSWORD: Configureert de containerafbeelding om het sa wachtwoord in te stellen, zoals gedefinieerd in deze sectie.

      valueFrom:
  secretKeyRef:
    name: mssql
    key: MSSQL_SA_PASSWORD

      Wanneer Kubernetes de container implementeert, verwijst deze naar het geheim met de naam mssql om de waarde voor het wachtwoord op te halen.

    • securityContext: Hiermee definieert u instellingen voor bevoegdheden en toegangsbeheer voor een pod of container. In dit geval wordt deze opgegeven op podniveau, zodat alle containers voldoen aan die beveiligingscontext. In de beveiligingscontext definiëren we de fsGroup met de waarde 10001, wat de Groep-ID (GID) is voor de mssql groep. Deze waarde betekent dat alle processen van de container ook deel uitmaken van de aanvullende GID 10001 (mssql). De eigenaar van het volume /var/opt/mssql en alle bestanden die in dat volume zijn gemaakt, zijn GID 10001 (de mssql groep).

    Waarschuwing

    Met behulp van het LoadBalancer servicetype is het SQL Server-exemplaar extern toegankelijk (via internet) op poort 1433.

    Sla het bestand op. Bijvoorbeeld: sqldeployment.yaml.

  2. Maak de implementatie, waar <path to sqldeployment.yaml file> is de locatie waar u het bestand hebt opgeslagen:

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

    De implementatie en de service worden gemaakt. Het SQL Server-exemplaar bevindt zich in een container die is verbonden met permanente opslag.

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

    De implementatie en de service worden gemaakt. Het SQL Server-exemplaar bevindt zich in een container die is verbonden met permanente opslag.

    Als u de status van de pod wilt weergeven, typt u kubectl get pod.

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

    De pod heeft de status Running. Deze status geeft aan dat de container klaar is. Nadat de implementatie is gemaakt, kan het enkele minuten duren voordat de pod zichtbaar is. De vertraging is omdat het cluster de mssql-server-linux-installatiekopie ophaalt uit het Microsoft Artifact Registry. Nadat de image de eerste keer is gedownload, kunnen volgende implementaties sneller zijn als de implementatie plaatsvindt op een knooppunt waarop de image al in de cache is opgeslagen.

  3. Controleer of de diensten worden uitgevoerd. Voer de volgende opdracht uit:

    kubectl get services

    Met deze opdracht worden services geretourneerd die actief zijn, en de interne en externe IP-adressen voor de services. Noteer het externe IP-adres voor de mssql-deployment-service. Gebruik dit IP-adres om verbinding te maken met 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

    Voer de volgende opdracht uit voor meer informatie over de status van de objecten in het Kubernetes-cluster. Vergeet niet om <MyResourceGroup> en <MyKubernetesClustername> te vervangen door uw resourcegroep en de naam van uw Kubernetes-cluster.

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

  4. U kunt ook controleren of de container als niet-root draait door de volgende opdracht uit te voeren, waarbij <nameOfSqlPod> de naam van uw SQL Server-pod is.

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

    U kunt de gebruikersnaam als mssql zien wanneer u whoami uitvoert. mssql is een niet-rootgebruiker.

    whoami

Verbinding maken met het SQL Server-exemplaar

U kunt verbinding maken met een toepassing buiten het virtuele Azure-netwerk met behulp van het sa account en het externe IP-adres voor de service. Gebruik het wachtwoord dat u hebt geconfigureerd als het OpenShift-geheim.

U kunt de volgende toepassingen gebruiken om verbinding te maken met het SQL Server-exemplaar.

Verbinding maken met sqlcmd

Voer de volgende opdracht uit om verbinding te maken met sqlcmd.

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

Vervang <External IP address> door het IP-adres voor de mssql-deployment service en <password> door uw complexe wachtwoord.

Waarschuwing

Uw wachtwoord moet voldoen aan het standaard SQL Server-wachtwoordbeleid . Standaard moet het wachtwoord ten minste acht tekens lang zijn en tekens bevatten uit drie van de volgende vier sets: hoofdletters, kleine letters, basis-10 cijfers en symbolen. Wachtwoorden mogen maximaal 128 tekens lang zijn. Gebruik wachtwoorden die zo lang en complex mogelijk zijn.

Fout en herstel verifiëren

Als u fouten en herstel wilt controleren, kunt u de pod verwijderen met de volgende stappen:

  1. Vermeld de pod waarop SQL Server wordt uitgevoerd.

    kubectl get pods

    Noteer de naam van de pod waarop SQL Server wordt uitgevoerd.

  2. Verwijder de pod.

    kubectl delete pod mssql-deployment-0

    mssql-deployment-0 is de waarde die in de vorige stap is geretourneerd voor de naam van de pod.

Kubernetes maakt de pod automatisch opnieuw om een SQL Server-exemplaar te herstellen en maakt verbinding met de permanente opslag. Gebruik kubectl get pods om te controleren of een nieuwe pod is geïmplementeerd. Gebruik kubectl get services om te controleren of het IP-adres voor de nieuwe container hetzelfde is.

Hulpmiddelen opruimen

Als u niet van plan bent om door de zelfstudies te gaan die volgen, schoont u uw onnodige resources op. Gebruik de az group delete opdracht om de resourcegroep, containerservice en alle gerelateerde resources te verwijderen. Vervang <MyResourceGroup> door de naam van de resourcegroep die uw cluster bevat.

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

Verwante inhoud