Compartilhar via

Guia de início rápido: implantar um cluster de contêiner do SQL Server no Azure ou no Red Hat OpenShift

Aplica-se a:SQL Server - Linux

Este guia de início rápido demonstra como configurar uma instância altamente disponível do SQL Server em um contêiner com armazenamento persistente, no Serviço Kubernetes do Azure (AKS) ou no Red Hat OpenShift. Se a instância do SQL Server falhar, o orquestrador a recriará automaticamente em um novo pod. O serviço de cluster também fornece resiliência contra uma falha de nó.

Este guia de início rápido usa as seguintes ferramentas de linha de comando para gerenciar o cluster.

Serviço de cluster Ferramenta de linha de comando
Azure Kubernetes Service (AKS) kubectl (Kubernetes CLI)
Azure Red Hat OpenShift oc (OpenShift CLI)

Pré-requisitos

Criar uma palavra-passe SA

A conta de administrador do sistema (sa) deve ser protegida com uma senha forte. A sua palavra-passe deve seguir a política de palavra-passe padrão do SQL Server . Por padrão, a senha deve ter pelo menos oito caracteres e conter caracteres de três dos quatro conjuntos a seguir: letras maiúsculas, letras minúsculas, dígitos de base 10 e símbolos. As palavras-passe podem ter até 128 caracteres. Use senhas tão longas e complexas quanto possível.

  1. Crie uma sa senha no cluster Kubernetes. O Kubernetes pode gerenciar informações confidenciais de configuração, como senhas como segredos.

  2. Para criar um segredo no Kubernetes nomeado mssql que contenha o valor <password> do MSSQL_SA_PASSWORD, execute o seguinte comando. Substitua <password> por sua senha complexa.

    Importante

    A variável de ambiente SA_PASSWORD foi preterida. Utilize MSSQL_SA_PASSWORD em substituição.

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

Criar armazenamento

Para um banco de dados em um cluster Kubernetes, você deve usar o armazenamento persistente. Você pode configurar um volume persistente e uma declaração de volume persistente no cluster do Kubernetes usando as seguintes etapas:

  1. Crie um manifesto para definir a classe de armazenamento e a declaração de volume persistente. O manifesto especifica o provisionador de armazenamento, os parâmetros e a política de recuperação. O cluster Kubernetes usa esse manifesto para criar o armazenamento persistente.

  2. O exemplo YAML a seguir define uma classe de armazenamento e uma declaração de volume persistente. O provisionador de classe de armazenamento é azure-disk, porque esse cluster do Kubernetes está no Azure. O tipo de conta de armazenamento é Standard_LRS. A declaração de volume persistente é denominada mssql-data. Os metadados de declaração de volume persistente incluem uma anotação conectando-os 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

    Salve o arquivo (por exemplo, pvc.yaml).

  3. Crie a declaração de volume persistente no Kubernetes, onde <path to pvc.yaml file> é o local onde você salvou o arquivo:

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

    O volume persistente é criado automaticamente como uma conta de armazenamento do Azure e vinculado à declaração de volume persistente.

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

  4. Verifique a declaração de volume persistente, onde <persistentVolumeClaim> é o nome da declaração de volume persistente:

    kubectl describe pvc <persistentVolumeClaim>

    Na etapa anterior, a declaração de volume persistente é denominada mssql-data. Para ver os metadados sobre a declaração de volume persistente, execute o seguinte comando:

    kubectl describe pvc mssql-data

    Os metadados retornados incluem um valor chamado Volume. Esse valor é mapeado para o nome do 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>

    O valor para volume corresponde a parte do nome do blob no portal do Azure.

  5. Verifique o volume persistente.

    kubectl describe pv

    kubectl Retorna metadados sobre o volume persistente que foi criado automaticamente e vinculado à declaração de volume persistente.

Criar uma implantação

O contêiner que hospeda a instância do SQL Server é descrito como um objeto de implantação do Kubernetes. A implantação cria um conjunto de réplicas. O conjunto de réplicas cria o pod.

Você cria um manifesto para descrever o contêiner, com base na imagem do SQL Server mssql-server-linux Docker.

  • O manifesto faz referência à mssql-server declaração de volume persistente e ao mssql segredo que você 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 persista após a recuperação da instância do SQL Server.
  • O manifesto descreve as solicitações e os limites de recursos. Estes baseiam-se nos requisitos mínimos do sistema.

  1. Crie um manifesto (um arquivo YAML) para descrever a implantação. O exemplo a seguir descreve uma implantação, incluindo um contêiner baseado na imagem de contêiner do SQL Server.

    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

    Copie o código anterior para um novo arquivo, chamado sqldeployment.yaml. Atualize os seguintes valores:

    • value: "Developer"MSSQL_PID : Define o contêiner para executar o SQL Server Developer edition. A edição do desenvolvedor não é licenciada para dados de produção. Se a implantação for para uso em produção, defina a edição apropriada (Enterprise, Standard, ou Express). Para obter mais informações, consulte Como licenciar o SQL Server.

    • persistentVolumeClaim: Este valor requer uma entrada para claimName: que mapeie para o nome usado para a declaração de volume persistente. Este tutorial utiliza mssql-data.

    • name: MSSQL_SA_PASSWORD: Configura a imagem do contêiner para definir a sa senha, conforme definido nesta seção.

      valueFrom:
  secretKeyRef:
    name: mssql
    key: MSSQL_SA_PASSWORD

      Quando o Kubernetes implanta o contêiner, ele se refere ao segredo nomeado mssql para obter o valor da senha.

    • securityContext: Define as configurações de privilégio e controle de acesso para um pod ou contêiner. Nesse caso, ele é especificado no nível do pod, portanto, todos os contêineres aderem a esse contexto de segurança. No contexto de segurança, definimos o fsGroup com o valor 10001, que é o ID de Grupo (GID) para o mssql grupo. Esse valor significa que todos os processos do contêiner também fazem parte do GID 10001 suplementar (mssql). O proprietário do volume /var/opt/mssql e de quaisquer arquivos criados nesse volume será o GID 10001 (o mssql grupo).

    Advertência

    Usando o LoadBalancer tipo de serviço, a instância do SQL Server pode ser acessada remotamente (via Internet) na porta 1433.

    Salve o arquivo. Por exemplo, sqldeployment.yaml.

  2. Crie a implantação, onde <path to sqldeployment.yaml file> é o local onde você salvou o arquivo:

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

    A implantação e o serviço são criados. A instância do SQL Server está em um contêiner, conectada ao armazenamento persistente.

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

    A implantação e o serviço são criados. A instância do SQL Server está em um contêiner, conectada ao armazenamento persistente.

    Para visualizar o status do pod, digite kubectl get pod.

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

    O pod tem um status de Running. Esse status indica que o contêiner está pronto. Depois que a implantação é criada, pode levar alguns minutos até que o pod fique visível. O atraso ocorre porque o cluster extrai a imagem mssql-server-linux do Microsoft Artifact Registry. Depois que a imagem for extraída pela primeira vez, as implantações subsequentes poderão ser mais rápidas se a implantação for para um nó que já tenha a imagem armazenada em cache.

  3. Verifique se os serviços estão em execução. Execute o seguinte comando:

    kubectl get services

    Esse comando retorna os serviços que estão em execução e os endereços IP internos e externos dos serviços. Observe o endereço IP externo do mssql-deployment serviço. Use esse endereço IP para se conectar ao 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

    Para obter mais informações sobre o status dos objetos no cluster do Kubernetes, execute o seguinte comando. Lembre-se de substituir <MyResourceGroup> e <MyKubernetesClustername> pelo seu grupo de recursos e nome do cluster Kubernetes:

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

  4. Você também pode verificar se o contêiner está sendo executado como não-raiz executando o seguinte comando, onde <nameOfSqlPod> é o nome do seu pod do SQL Server:

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

    Você pode ver o nome de usuário como mssql se executar whoami. mssql é um usuário não-root.

    whoami

Conectar-se à instância do SQL Server

Você pode se conectar a um aplicativo de fora da rede virtual do Azure, usando a sa conta e o endereço IP externo do serviço. Use a senha que você configurou como o segredo do OpenShift.

Você pode usar os seguintes aplicativos para se conectar à instância do SQL Server.

Conecte-se ao sqlcmd

Para se conectar com sqlcmd, execute o seguinte comando.

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

Substitua <External IP address> pelo endereço IP do mssql-deployment serviço e <password> pela sua senha complexa.

Atenção

A sua palavra-passe deve seguir a política de palavra-passe padrão do SQL Server . Por padrão, a senha deve ter pelo menos oito caracteres e conter caracteres de três dos quatro conjuntos a seguir: letras maiúsculas, letras minúsculas, dígitos de base 10 e símbolos. As palavras-passe podem ter até 128 caracteres. Use senhas tão longas e complexas quanto possível.

Verificar falha e recuperação

Para verificar a falha e a recuperação, pode-se eliminar o pod segundo os seguintes passos:

  1. Liste o pod que executa o SQL Server.

    kubectl get pods

    Observe o nome do pod que executa o SQL Server.

  2. Exclua o pod.

    kubectl delete pod mssql-deployment-0

    mssql-deployment-0 é o valor retornado na etapa anterior para o nome do pod.

O Kubernetes recria automaticamente o pod para recuperar uma instância do SQL Server e se conecta ao armazenamento persistente. Use kubectl get pods para verificar se um novo pod está implantado. Use kubectl get services para verificar se o endereço IP do novo contêiner é o mesmo.

Limpar recursos

Se você não planeja passar pelos tutoriais que se seguem, limpe seus recursos desnecessários. Use o az group delete comando para remover o grupo de recursos, o serviço de contêiner e todos os recursos relacionados. Substitua <MyResourceGroup> pelo nome do grupo de recursos que contém o cluster.

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

Conteúdo relacionado