Distribuera en Azure SQL Edge-container i Kubernetes

  • Artikel

Viktigt

Azure SQL Edge stöder inte längre ARM64-plattformen.

Azure SQL Edge kan distribueras i ett Kubernetes-kluster både som en IoT Edge-modul via Azure IoT Edge som körs på Kubernetes eller som en fristående containerpodd. I resten av den här artikeln fokuserar vi på den fristående containerdistributionen på ett Kubernetes-kluster. Information om hur du distribuerar Azure IoT Edge på Kubernetes finns i Azure IoT Edge på Kubernetes (förhandsversion).

Den här självstudien visar hur du konfigurerar en Azure SQL Edge-instans med hög tillgänglighet i en container i ett Kubernetes-kluster.

  • Skapa ett SA-lösenord
  • Skapa lagring
  • Skapa distributionen
  • Ansluta med SQL Server Management Studio (SSMS)
  • Verifiera fel och återställning

Kubernetes 1.6 och senare har stöd för lagringsklasser, beständiga volymanspråk och Azure-diskvolymtypen. Du kan skapa och hantera dina Azure SQL Edge-instanser internt i Kubernetes. Exemplet i den här artikeln visar hur du skapar en distribution för att uppnå en konfiguration med hög tillgänglighet som liknar en redundansklusterinstans för delad disk. I den här konfigurationen spelar Kubernetes rollen som klusterorkestrerare. När en Azure SQL Edge-instans i en container misslyckas startar orchestrator en annan instans av containern som ansluter till samma beständiga lagring.

Diagram över Azure SQL Edge i ett Kubernetes-kluster.

I föregående diagram azure-sql-edge är en container i en podd. Kubernetes samordnar resurserna i klustret. En replikuppsättning säkerställer att podden återställs automatiskt efter ett nodfel. Program ansluter till tjänsten. I det här fallet representerar tjänsten en lastbalanserare som är värd för en IP-adress som förblir densamma efter fel i azure-sql-edge.

I följande diagram har containern azure-sql-edge misslyckats. Som orkestrerare garanterar Kubernetes rätt antal felfria instanser i replikuppsättningen och startar en ny container enligt konfigurationen. Orkestreraren startar en ny podd på samma nod och azure-sql-edge återansluter till samma beständiga lagring. Tjänsten ansluter till den återskapade azure-sql-edge.

Diagram över Azure SQL Edge i ett Kubernetes-kluster efter poddfel.

I följande diagram misslyckades noden som är värd för containern azure-sql-edge . Orkestreraren startar den nya podden på en annan nod och azure-sql-edge återansluter till samma beständiga lagring. Tjänsten ansluter till den återskapade azure-sql-edge.

Diagram över Azure SQL Edge i ett Kubernetes-kluster efter nodfel.

Förutsättningar

  • Kubernetes-kluster

    • Självstudien kräver ett Kubernetes-kluster. Stegen använder kubectl för att hantera klustret.

    • I den här självstudien använder vi Azure Kubernetes Service för att distribuera Azure SQL Edge. Se Distribuera ett Azure Kubernetes Service-kluster (AKS) för att skapa och ansluta till ett Kubernetes-kluster med en nod i AKS med kubectl.

    Anteckning

    För att skydda mot nodfel kräver ett Kubernetes-kluster mer än en nod.

  • Azure CLI

    • Anvisningarna i den här självstudien har verifierats mot Azure CLI 2.10.1.

Skapa ett Kubernetes-namnområde för SQL Edge-distribution

Skapa ett nytt namnområde i kubernetes-klustret. Det här namnområdet används för att distribuera SQL Edge och alla nödvändiga artefakter. Mer information om Kubernetes-namnrymder finns i namnrymder.

kubectl create namespace <namespace name>

Skapa ett SA-lösenord

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

Följande kommando skapar ett lösenord för SA-kontot:

kubectl create secret generic mssql --from-literal=SA_PASSWORD="MyC0m9l&xP@ssw0rd" -n <namespace name>

Ersätt MyC0m9l&xP@ssw0rd med ett komplext lösenord.

Skapa lagring

Konfigurera ett beständigt volym - och beständiga volymanspråk i Kubernetes-klustret. Slutför 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.

    I följande yaml-exempel definieras en lagringsklass och ett beständigt volymanspråk. Lagringsklassetableraren är azure-disk, eftersom det här Kubernetes-klustret finns i Azure. Lagringskontotypen är Standard_LRS. Det beständiga volymanspråket heter mssql-data. Beständiga metadata för volymanspråk innehåller en kommentar som ansluter den 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).

  2. Skapa det beständiga volymanspråket i Kubernetes.

    kubectl apply -f <Path to pvc.yaml file> -n <namespace name>

    <Path to pvc.yaml file> är den plats där du sparade filen.

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

    Skärmbild av beständiga kommandot för volymanspråk.

  3. Verifiera det beständiga volymanspråket.

    kubectl describe pvc <PersistentVolumeClaim>  -n <name of the namespace>

    <PersistentVolumeClaim> är namnet på det beständiga volymanspråket.

    I föregående steg heter mssql-datadet beständiga volymanspråket . Om du vill se metadata om det beständiga volymanspråket kör du följande kommando:

    kubectl describe pvc mssql-data  -n <namespace name>

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

    Skärmbild av returnerade metadata, inklusive Volym.

  4. Kontrollera den beständiga volymen.

    kubectl describe pv -n <namespace name>

    kubectl returnerar metadata om den beständiga volymen som skapades automatiskt och var bunden till det beständiga volymanspråket.

Skapa distributionen

I det här exemplet beskrivs containern som är värd för Azure SQL Edge-instansen som ett Kubernetes-distributionsobjekt. Distributionen skapar en replikuppsättning. Replikuppsättningen skapar podden.

I det här steget skapar du ett manifest som beskriver containern baserat på Azure SQL Edge Docker-avbildningen. Manifestet refererar till det mssql-data 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 Azure SQL Edge-instansen har återställts.

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

    apiVersion: apps/v1
kind: Deployment
metadata:
  name: sqledge-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: sqledge
  template:
    metadata:
      labels:
        app: sqledge
    spec:
      volumes:
        - name: sqldata
          persistentVolumeClaim:
            claimName: mssql-data
      containers:
        - name: azuresqledge
          image: mcr.microsoft.com/azure-sql-edge:latest
          ports:
            - containerPort: 1433
          volumeMounts:
            - name: sqldata
              mountPath: /var/opt/mssql
          env:
            - name: MSSQL_PID
              value: "Developer"
            - name: ACCEPT_EULA
              value: "Y"
            - name: SA_PASSWORD
              valueFrom:
                secretKeyRef:
                  name: mssql
                  key: SA_PASSWORD
            - name: MSSQL_AGENT_ENABLED
              value: "TRUE"
            - name: MSSQL_COLLATION
              value: "SQL_Latin1_General_CP1_CI_AS"
            - name: MSSQL_LCID
              value: "1033"
      terminationGracePeriodSeconds: 30
      securityContext:
        fsGroup: 10001
---
apiVersion: v1
kind: Service
metadata:
  name: sqledge-deployment
spec:
  selector:
    app: sqledge
  ports:
    - protocol: TCP
      port: 1433
      targetPort: 1433
      name: sql
  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öras Azure SQL Edge Developer Edition. Developer Edition är inte licensierat för produktionsdata. Om distributionen är avsedd för produktionsanvändning anger du utgåvan till Premium.

      Anteckning

      Mer information finns i Licensiera Azure SQL Edge.

    • 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 volymanspråket. I den här självstudien används mssql-data.

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

      valueFrom:
  secretKeyRef:
    name: mssql
    key: SA_PASSWORD

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

    Anteckning

    Genom att använda LoadBalancer tjänsttypen är Azure SQL Edge-instansen tillgänglig via fjärranslutning (via Internet) på port 1433.

    Spara filen (till exempel sqledgedeploy.yaml).

  2. Skapa distributionen.

    kubectl apply -f <Path to sqledgedeploy.yaml file> -n <namespace name>

    <Path to sqldeployment.yaml file> är den plats där du sparade filen.

    Skärmbild av distributionskommandot.

    Distributionen och tjänsten skapas. Azure SQL Edge-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 -n <namespace name>.

    Skärmbild av kommandot hämta podd.

    I föregående bild har podden statusen Running. Den här statusen anger att containern är klar. Det här kan ta flera minuter.

    Anteckning

    När distributionen har skapats kan det ta några minuter innan podden visas. Fördröjningen beror på att klustret hämtar Azure SQL Edge-containeravbildningen från Docker-hubben. När avbildningen hämtas första gången kan efterföljande distributioner gå snabbare om distributionen sker till en nod som redan har avbildningen cachelagrad.

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

    kubectl get services -n <namespace name>

    Det här kommandot returnerar tjänster som körs samt interna och externa IP-adresser för tjänsterna. Anteckna den externa IP-adressen för mssql-deployment tjänsten. Använd den här IP-adressen för att ansluta till Azure SQL Edge.

    Skärmbild av kommandot hämta tjänst.

    Om du vill ha mer information om status för objekten i Kubernetes-klustret kör du:

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

Ansluta till Azure SQL Edge-instansen

Om du har konfigurerat containern enligt beskrivningen kan du ansluta till ett program utanför det virtuella Azure-nätverket. sa Använd kontot och den externa IP-adressen för tjänsten. Använd lösenordet som du konfigurerade som Kubernetes-hemligheten. Mer information om hur du ansluter till en Azure SQL Edge-instans finns i Ansluta till Azure SQL Edge.

Verifiera fel och återställning

Om du vill verifiera fel och återställning kan du ta bort podden. Gör följande:

  1. Visa en lista över podden som körs Azure SQL Edge.

    kubectl get pods -n <namespace name>

    Anteckna namnet på den podd som körs Azure SQL Edge.

  2. Ta bort podden.

    kubectl delete pod sqledge-deployment-7df66c9999-rc9xl

    sqledge-deployment-7df66c9999-rc9xl är värdet som returnerades från föregående steg för poddnamnet.

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

Sammanfattning

I den här självstudien har du lärt dig hur du distribuerar Azure SQL Edge-containrar till ett Kubernetes-kluster för hög tillgänglighet.

  • Skapa ett SA-lösenord
  • Skapa lagring
  • Skapa distributionen
  • Ansluta med Azure SQL Edge Management Studios (SSMS)
  • Verifiera fel och återställning

Nästa steg