Compartilhar via


Início Rápido: Implantar um cluster de contêiner do SQL Server no Azure

Aplica-se a: SQL Server – Linux

Este início rápido demonstra como configurar uma instância do SQL Server altamente disponível em um contêiner com armazenamento persistente no AKS (Serviço de Kubernetes do Azure) 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 oferece resiliência com relação a uma falha de nó.

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

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

Pré-requisitos

Criar uma senha SA

  1. Crie a senha SA no cluster Kubernetes. O Kubernetes pode gerenciar informações de configuração confidenciais, por exemplo, senhas como segredos.

  2. Para criar um segredo no Kubernetes chamado mssql que contém o valor MyC0m9l&xP@ssw0rd para MSSQL_SA_PASSWORD, execute o comando a seguir. Lembre-se de escolher sua senha complexa:

    Importante

    A variável de ambiente SA_PASSWORD foi preterida. Use MSSQL_SA_PASSWORD em vez disso.

    kubectl create secret generic mssql --from-literal=MSSQL_SA_PASSWORD="MyC0m9l&xP@ssw0rd"
    

Criar armazenamento

Para um banco de dados em um cluster do Kubernetes, você precisa usar armazenamento persistente. Configure um volume persistente e uma declaração de volume persistente no cluster 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 de 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 Kubernetes está no Azure. O tipo de conta de armazenamento é Standard_LRS. A declaração de volume persistente é denominada mssql-data. Os metadados da declaração de volume persistente incluem uma anotação que os conecta 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 associado à declaração de volume persistente.

    storageclass "azure-disk" created
    persistentvolumeclaim "mssql-data" created
    
  4. Verifique a declaração de volume persistente, onde <persistentVolumeClaim> está 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 do volume corresponde a parte do nome do blob na seguinte imagem do portal do Azure:

    Captura de tela do nome do blob do portal do Azure.

  5. Verifique o volume persistente.

    kubectl describe pv
    

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

Criar a 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 Docker mssql-server-linux do SQL Server.

  • O manifesto referencia a declaração de volume persistente do mssql-server e o segredo mssql que você já aplicou ao cluster Kubernetes.
  • O manifesto também descreve um serviço. Esse 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 Server.
  • O manifesto descreve as solicitações e os limites do recurso. Eles se baseiam 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, denominado sqldeployment.yaml. Atualize os seguintes valores:

    • MSSQL_PID value: "Developer": define o contêiner para executar o SQL Server Developer Edition. A edição Developer 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 saber mais, confira Como licenciar o SQL Server.

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

    • name: MSSQL_SA_PASSWORD: configura a imagem de contêiner para definir a senha SA, conforme definido nesta seção.

      valueFrom:
        secretKeyRef:
          name: mssql
          key: MSSQL_SA_PASSWORD
      

      Quando o Kubernetes implanta o contêiner, ele refere-se ao segredo chamado 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 e, 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 é a GID (ID de Grupo) do grupo mssql. 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 todos os arquivos criados nesse volume será a GID 10001 (o grupo mssql).

    Aviso

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

    Salve o arquivo. Por exemplo, sqldeployment.yaml.

  2. Crie a implantação, em que <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 exibir 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. Após a criação da implantação, pode levar alguns minutos antes que o pod fique visível. O atraso ocorre porque o cluster efetua pull da imagem mssql-server-linux do Registro de Artefato da Microsoft. Depois o pull da imagem for efetuado pela primeira vez, implantações subsequentes poderão ser mais rápidas se a implantação for para um nó que já tem a imagem armazenada em cache.

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

    kubectl get services
    

    Esse comando retorna serviços em execução e os endereços IP internos e externos para os serviços. Observe o endereço IP externo do serviço mssql-deployment. Use o endereço IP para conectar-se 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 saber mais sobre o status dos objetos no cluster Kubernetes, execute o comando a seguir. Lembre-se de substituir <MyResourceGroup> e <MyKubernetesClustername> com o grupo de recursos e o nome do cluster do Kubernetes:

    az aks browse --resource-group <MyResourceGroup> --name <MyKubernetesClustername>
    
  4. Você também pode verificar se o contêiner está em execução como não raiz executando o seguinte comando, em que <nameOfSqlPod> é o nome do pod do SQL Server:

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

    Você poderá ver o nome de usuário como mssql se executar whoami. mssql que é um usuário não raiz.

    whoami
    

Conectar-se à instância do SQL Server

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

É possível usar os seguintes aplicativos para se conectar à instância do SQL Server.

Conectar-se com sqlcmd

Para se conectar com sqlcmd, execute o seguinte comando:

sqlcmd -S <External IP Address> -U sa -P "MyC0m9l&xP@ssw0rd"

Substitua os seguintes valores:

  • <External IP Address> pelo endereço IP do serviço mssql-deployment
  • MyC0m9l&xP@ssw0rd com a sua senha complexa

Verificar falha e recuperação

Para verificar a falha e a recuperação, exclua o pod realizando as seguintes etapas:

  1. Listar o pod que está executando o SQL Server.

    kubectl get pods
    

    Anotar o nome do pod que está executando o SQL Server.

  2. Excluir o pod.

    kubectl delete pod mssql-deployment-0
    

    mssql-deployment-0 é o valor retornado da 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 foi implantado. Use kubectl get services para verificar se o endereço IP do novo contêiner é o mesmo.

Limpar os recursos

Se você não planeja passar pelos tutoriais a seguir, limpe os recursos desnecessários. Use o comando az group delete 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