Implementar um contentor do SQL do Azure Edge no Kubernetes

Artigo
09/14/2023

Importante

SQL do Azure Edge já não suporta a plataforma ARM64.

SQL do Azure Edge pode ser implementado num cluster do Kubernetes como um módulo IoT Edge através do Azure IoT Edge em execução no Kubernetes ou como um pod de contentor autónomo. Para o resto deste artigo, vamos focar-nos na implementação de contentores autónomos num cluster do Kubernetes. Para obter informações sobre como implementar o Azure IoT Edge no Kubernetes, veja Azure IoT Edge no Kubernetes (pré-visualização).

Este tutorial demonstra como configurar uma instância do SQL do Azure Edge de elevada disponibilidade num contentor num cluster do Kubernetes.

Criar uma palavra-passe SA
Criar armazenamento
Criar a implementação
Ligar com SQL Server Management Studio (SSMS)
Verificar a falha e a recuperação

O Kubernetes 1.6 e posterior tem suporte para classes de armazenamento, afirmações de volume persistentes e o tipo de volume de disco do Azure. Pode criar e gerir as instâncias do SQL do Azure Edge de forma nativa no Kubernetes. O exemplo neste artigo mostra como criar uma implementação para obter uma configuração de elevada disponibilidade semelhante a uma instância de cluster de ativação pós-falha de disco partilhado. Nesta configuração, o Kubernetes desempenha o papel de orquestrador de cluster. Quando uma instância do SQL do Azure Edge num contentor falha, o orchestrator arranca outra instância do contentor que se anexa ao mesmo armazenamento persistente.

Diagrama do SQL do Azure Edge num cluster do Kubernetes.

No diagrama anterior, azure-sql-edge encontra-se um contentor num pod. O Kubernetes orquestra os recursos no cluster. Um conjunto de réplicas garante que o pod é recuperado automaticamente após uma falha do nó. As aplicações ligam-se ao serviço. Neste caso, o serviço representa um balanceador de carga que aloja um endereço IP que permanece o mesmo após a falha do azure-sql-edge.

No diagrama seguinte, o azure-sql-edge contentor falhou. Como orquestrador, o Kubernetes garante a contagem correta de instâncias em bom estado de funcionamento no conjunto de réplicas e inicia um novo contentor de acordo com a configuração. O orquestrador inicia um novo pod no mesmo nó e azure-sql-edge volta a ligar-se ao mesmo armazenamento persistente. O serviço liga-se ao recriado azure-sql-edge.

Diagrama do SQL do Azure Edge num cluster do Kubernetes após a falha do pod.

No diagrama seguinte, o nó que aloja o azure-sql-edge contentor falhou. O orquestrador inicia o novo pod num nó diferente e azure-sql-edge volta a ligar-se ao mesmo armazenamento persistente. O serviço liga-se ao recriado azure-sql-edge.

Diagrama do SQL do Azure Edge num cluster do Kubernetes após a falha do nó.

Pré-requisitos

Cluster do Kubernetes
- O tutorial requer um cluster do Kubernetes. Os passos utilizam kubectl para gerir o cluster.
- Para efeitos deste tutorial, estamos a utilizar Azure Kubernetes Service para implementar o SQL do Azure Edge. Veja Deploy an Azure Kubernetes Service (AKS) cluster to create and connect to a single-node Kubernetes cluster in AKS with kubectl.
Nota

Para proteger contra falhas de nós, um cluster do Kubernetes requer mais do que um nó.
CLI do Azure
- As instruções neste tutorial foram validadas na CLI 2.10.1 do Azure.

Criar um espaço de nomes do Kubernetes para a implementação do SQL Edge

Crie um novo espaço de nomes no cluster do kubernetes. Este espaço de nomes é utilizado para implementar o SQL Edge e todos os artefactos necessários. Para obter mais informações sobre espaços de nomes do Kubernetes, veja espaços de nomes.

kubectl create namespace <namespace name>

Criar uma palavra-passe SA

Crie uma palavra-passe SA no cluster do Kubernetes. O Kubernetes pode gerir informações de configuração confidenciais, como palavras-passe como segredos.

O comando seguinte cria uma palavra-passe para a conta SA:

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

Substitua por MyC0m9l&xP@ssw0rd uma palavra-passe complexa.

Criar armazenamento

Configure um volume persistente e uma afirmação de volume persistente no cluster do Kubernetes. Siga os seguintes passos:

Crie um manifesto para definir a classe de armazenamento e a afirmação de volume persistente. O manifesto especifica o aprovisionador de armazenamento, os parâmetros e a política de recuperação. O cluster do Kubernetes utiliza este manifesto para criar o armazenamento persistente.

O exemplo yaml seguinte define uma classe de armazenamento e uma afirmação de volume persistente. O aprovisionador da classe de armazenamento é azure-disk, porque este cluster do Kubernetes está no Azure. O tipo de conta de armazenamento é Standard_LRS. A afirmação de volume persistente tem o nome mssql-data. Os metadados de afirmação de volume persistente incluem uma anotação que a liga de volta à classe de armazenamento.
```
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
```
Guarde o ficheiro (por exemplo, pvc.yaml).
Crie a afirmação de volume persistente no Kubernetes.
```
kubectl apply -f <Path to pvc.yaml file> -n <namespace name>
```
<Path to pvc.yaml file> é a localização onde guardou o ficheiro.

O volume persistente é criado automaticamente como uma conta de armazenamento do Azure e vinculado à afirmação de volume persistente.
Verifique a afirmação de volume persistente.
```
kubectl describe pvc <PersistentVolumeClaim>  -n <name of the namespace>
```
<PersistentVolumeClaim> é o nome da afirmação de volume persistente.

No passo anterior, a afirmação de volume persistente chama-se mssql-data. Para ver os metadados sobre a afirmação de volume persistente, execute o seguinte comando:
```
kubectl describe pvc mssql-data  -n <namespace name>
```
Os metadados devolvidos incluem um valor chamado Volume. Este valor mapeia para o nome do blob.
Verifique o volume persistente.
```
kubectl describe pv -n <namespace name>
```
kubectl devolve metadados sobre o volume persistente que foi criado automaticamente e vinculado à afirmação de volume persistente.

Criar a implementação

Neste exemplo, o contentor que aloja a instância do SQL do Azure Edge é descrito como um objeto de implementação do Kubernetes. A implementação cria um conjunto de réplicas. O conjunto de réplicas cria o pod.

Neste passo, crie um manifesto para descrever o contentor com base na imagem do Docker do SQL do Azure Edge. O manifesto referencia a mssql-data afirmação de volume persistente e o mssql segredo que já aplicou ao cluster do Kubernetes. O manifesto também descreve um serviço. Este serviço é um balanceador de carga. O balanceador de carga garante que o endereço IP persiste após a recuperação da instância do SQL do Azure Edge.

Crie um manifesto (um ficheiro YAML) para descrever a implementação. O exemplo seguinte descreve uma implementação, incluindo um contentor com base na imagem de contentor do SQL do Azure Edge.

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

Copie o código anterior para um novo ficheiro, com o nome sqldeployment.yaml. Atualize os seguintes valores:

value: "Developer"MSSQL_PID: define o contentor para ser executado SQL do Azure Edição para Programadores do Edge. A edição de programador não está licenciada para dados de produção. Se a implementação for para utilização de produção, defina a edição como Premium.

Nota

Para obter mais informações, veja Como licenciar o SQL do Azure Edge.
persistentVolumeClaim: este valor requer uma entrada para claimName: que mapeie para o nome utilizado para a afirmação de volume persistente. Este tutorial utiliza mssql-data.
name: SA_PASSWORD: configura a imagem de contentor para definir a palavra-passe SA, conforme definido nesta secção.
```
valueFrom:
  secretKeyRef:
    name: mssql
    key: SA_PASSWORD
```
Quando o Kubernetes implementa o contentor, refere-se ao segredo com o nome mssql para obter o valor da palavra-passe.

Nota

Ao utilizar o LoadBalancer tipo de serviço, a instância do SQL do Azure Edge é acessível remotamente (através da Internet) na porta 1433.

Guarde o ficheiro (por exemplo, sqledgedeploy.yaml).

Crie a implementação.
```
kubectl apply -f <Path to sqledgedeploy.yaml file> -n <namespace name>
```
<Path to sqldeployment.yaml file> é a localização onde guardou o ficheiro.

A implementação e o serviço são criados. A instância do SQL do Azure Edge está num contentor, ligada ao armazenamento persistente.

Para ver o estado do pod, escreva kubectl get pod -n <namespace name>.

Na imagem anterior, o pod tem o estado .Running Este estado indica que o contentor está pronto. Este processo pode demorar vários minutos.

Nota

Após a criação da implementação, pode demorar alguns minutos até que o pod seja visível. O atraso deve-se ao facto de o cluster solicitar a imagem de contentor do SQL do Azure Edge do hub do Docker. Depois de a imagem ser extraída pela primeira vez, as implementações subsequentes poderão ser mais rápidas se a implementação estiver num nó que já tenha a imagem em cache.
Verifique se os serviços estão em execução. Execute o seguinte comando:
```
kubectl get services -n <namespace name>
```
Este comando devolve serviços em execução, bem como os endereços IP internos e externos dos serviços. Repare no endereço IP externo do mssql-deployment serviço. Utilize este endereço IP para ligar ao SQL do Azure Edge.

Para obter mais informações sobre o estado dos objetos no cluster do Kubernetes, execute:
```
az aks browse --resource-group <MyResourceGroup> --name <MyKubernetesClustername>
```

Ligar à instância do SQL do Azure Edge

Se tiver configurado o contentor conforme descrito, pode ligar-se a uma aplicação de fora da rede virtual do Azure. Utilize a sa conta e o endereço IP externo do serviço. Utilize a palavra-passe que configurou como segredo do Kubernetes. Para obter mais informações sobre como ligar a uma instância do SQL do Azure Edge, veja Ligar ao SQL do Azure Edge.

Verificar a falha e a recuperação

Para verificar a falha e a recuperação, pode eliminar o pod. Efetue os seguintes passos:

Liste o pod em execução SQL do Azure Edge.
```
kubectl get pods -n <namespace name>
```
Tenha em atenção o nome do pod em execução SQL do Azure Edge.
Elimine o pod.
```
kubectl delete pod sqledge-deployment-7df66c9999-rc9xl
```
sqledge-deployment-7df66c9999-rc9xl é o valor devolvido do passo anterior para o nome do pod.

O Kubernetes recria automaticamente o pod para recuperar uma instância do SQL do Azure Edge e ligar ao armazenamento persistente. Utilize kubectl get pods para verificar se um novo pod está implementado. Utilize kubectl get services para verificar se o endereço IP do novo contentor é o mesmo.

Resumo

Neste tutorial, aprendeu a implementar contentores do SQL do Azure Edge num cluster do Kubernetes para elevada disponibilidade.

Criar uma palavra-passe SA
Criar armazenamento
Criar a implementação
Ligar-se ao SQL do Azure Edge Management Studios (SSMS)
Verificar a falha e a recuperação

Partilhar via