O Google usa tecnologia de IA na tradução de conteúdos para seu idioma de preferência. As traduções com IA podem ter erros.

Como configurar uma instância de cluster de failover do SQL Server no Linux com um disco de vários gravadores

Para alcançar alta disponibilidade do SQL Server em duas zonas distintas no Compute Engine, implante uma instância de cluster de failover (FCI) do SQL Server no Linux que use discos de vários gravadores. Ao contrário das arquiteturas tradicionais sem compartilhamento, essa configuração permite anexar simultaneamente nós em zonas diferentes ao mesmo disco. Neste guia, descrevemos como implantar um FCI do SQL Server altamente disponível no Linux no Compute Engine usando a replicação síncrona de baixa latência do Google Cloud Hyperdisk.

Esse design garante que o SQL Server permaneça disponível mesmo no caso improvável de uma interrupção zonal. A combinação do Pacemaker para orquestração de cluster com a resiliência entre zonas do Compute Engine oferece uma solução robusta e de alto desempenho para cargas de trabalho de banco de dados essenciais que exigem a simplicidade do armazenamento compartilhado.

Benefícios de implementar alta disponibilidade com discos de vários gravadores

Usar uma FCI do SQL Server com discos de vários gravadores em vez de grupos de disponibilidade Always On (AG) no Linux remove a complexidade de gerenciar várias cópias de dados e a sobrecarga de sincronização que as configurações de AG causam.

Uma arquitetura de volume compartilhado também é mais eficiente em termos de armazenamento quando comparada a arquiteturas de AG que usam réplicas de dados completas em cada nó. Os volumes compartilhados também podem reduzir os custos de disco em cenários de espelhamento.

Principais destaques desta arquitetura

Redundância zonal: proteção de dados no caso raro de falha de um nó ou interrupção zonal.
Gerenciamento simplificado: reduz a complexidade de gerenciar várias cópias de dados em comparação com os grupos de disponibilidade Always On.
Eficiência de armazenamento: usa um único volume compartilhado para dados e registros, otimizado com capacidade de vários gravadores.
Orquestração nativa do Linux: usa extensões de alta disponibilidade (HAE) padrão do setor para failover perfeito.

Em um ambiente local, é possível permitir que o WSFC execute avisos de ARP se um failover ocorrer para notificar o equipamento de rede sobre uma mudança de endereço IP. No entanto, oGoogle Cloudignora os anúncios de ARP. Portanto, é necessário implementar um balanceador de carga interno (consulte Como executar o cluster de failover do Windows Server).

Arquitetura

O artigo pressupõe que você tenha conhecimento básico sobre o SQL Server, o Active Directory e o Compute Engine.

Objetivos

Neste tutorial, mostramos como concluir as seguintes tarefas para alcançar seu objetivo:

Crie uma implantação do SQL Server no Linux.
Crie, anexe e configure um disco de vários gravadores.
Configure o cluster do Pacemaker.
Configure o balanceador de carga.
Faça um teste de failover.

Custos

Neste tutorial, usamos componentes faturáveis do Google Cloud, incluindo:

Use a Calculadora de preços para gerar uma estimativa de custo com base no uso previsto.

Antes de começar

Para este tutorial, você precisa de um projeto Google Cloud . É possível criar um novo projeto ou selecionar um que já foi criado:
1. No console do Google Cloud , na página do seletor de projetos, selecione ou crie um projeto do Google Cloud .
  Funções necessárias para selecionar ou criar um projeto
  - Selecionar um projeto: não é necessário um papel específico do IAM para selecionar um projeto. Você pode escolher qualquer projeto em que tenha recebido um papel.
  - Criar um projeto: para criar um projeto, é necessário ter o papel de Criador de projetos (roles/resourcemanager.projectCreator), que contém a permissão resourcemanager.projects.create. Saiba como conceder papéis.
  Observação: se você não pretende manter os recursos criados neste procedimento, crie um projeto novo em vez de selecionar um que já existe. Depois de concluir essas etapas, é possível excluir o projeto. Para fazer isso, basta remover todos os recursos associados a ele.
  
  Acessar o seletor de projetos
2. Verifique se o faturamento está ativado para o projeto do Google Cloud .
3. No console do Google Cloud , ative o Cloud Shell.
  
  Ativar o Cloud Shell

Preparar o projeto e a rede

Para preparar o projeto Google Cloud e a VPC para a implantação da FCI do SQL Server, faça o seguinte:

No console do Google Cloud , abra o Cloud Shell clicando no botão Ativar o Cloud Shell .

Acesse o console do Google Cloud .
Defina o ID do projeto padrão:
```
gcloud config set project PROJECT_ID
```
Substitua PROJECT_ID pelo ID do seu projeto do Google Cloud .
Defina sua região padrão:
```
gcloud config set compute/region REGION
```
Substitua REGION pelo ID da região em que você quer implantar.

Criar os nós do cluster

Implante duas VMs como nós de cluster e uma terceira como um cliente dedicado para validar a conectividade e o desempenho de failover.

Inicialize as seguintes variáveis que serão usadas nos comandos restantes.

BOOT_DISK_SIZE=50
BOOT_IOPS=10000
BOOT_THROUGHPUT=400
DATA_IOPS=10000
DATA_THROUGHPUT=400
DATA_DISK_SIZE=200
REGION=$(gcloud config get-value compute/region)
ZONE1=$REGION-a
ZONE2=$REGION-b
SUBNET=SUBNET_NAME
MACHINE_TYPE=c3-standard-8
VPC_NAME=VPC_NAME

Crie dois discos regionais, um de dados e outro para o registro. Para permitir que ambas as instâncias acessem os discos, ative o modo de vários gravadores para os dois discos com a flag --access-mode=READ_WRITE_MANY.

gcloud compute disks create sqlfci-mw-data-disk \
--size=$DATA_DISK_SIZE \
--type=hyperdisk-balanced-high-availability \
--region=$REGION \
--replica-zones=$ZONE1,$ZONE2 \
--provisioned-iops=$DATA_IOPS \
--provisioned-throughput=$DATA_THROUGHPUT \
--access-mode=READ_WRITE_MANY

gcloud compute disks create sqlfci-mw-log-disk \
--size=$DATA_DISK_SIZE \
--type=hyperdisk-balanced-high-availability \
--region=$REGION \
--replica-zones=$ZONE1,$ZONE2 \
--provisioned-iops=$DATA_IOPS \
--provisioned-throughput=$DATA_THROUGHPUT \
--access-mode=READ_WRITE_MANY

Crie as VMs do Linux e anexe os discos de vários gravadores que você criou.

gcloud compute instances create node-1 \
--boot-disk-size=$BOOT_DISK_SIZE \
--boot-disk-type=hyperdisk-balanced \
--boot-disk-provisioned-iops=$BOOT_IOPS \
--boot-disk-provisioned-throughput=$BOOT_THROUGHPUT \
--zone $ZONE1 \
--machine-type $MACHINE_TYPE \
--subnet $SUBNET \
--image-family ubuntu-2204-lts \
--image-project ubuntu-os-cloud \
--disk="name=sqlfci-mw-data-disk,scope=regional,mode=rw" \
--disk="name=sqlfci-mw-log-disk,scope=regional,mode=rw" \
--scopes=compute-rw,trace,service-control,service-management,pubsub,monitoring-write,logging-write,storage-rw \
--tags=sqlfci

gcloud compute instances create node-2 \
--boot-disk-size=$BOOT_DISK_SIZE \
--boot-disk-type=hyperdisk-balanced \
--boot-disk-provisioned-iops=$BOOT_IOPS \
--boot-disk-provisioned-throughput=$BOOT_THROUGHPUT \
--zone $ZONE2 \
--machine-type $MACHINE_TYPE \
--subnet $SUBNET \
--image-family ubuntu-2204-lts \
--image-project ubuntu-os-cloud \
--disk="name=sqlfci-mw-data-disk,scope=regional,mode=rw" \
--disk="name=sqlfci-mw-log-disk,scope=regional,mode=rw" \
--scopes=compute-rw,trace,service-control,service-management,pubsub,monitoring-write,logging-write,storage-rw \
--tags=sqlfci

Crie a VM cliente do Windows, cl-node, que você vai usar para testar a conexão.

gcloud compute instances create cl-node \
--boot-disk-size=100 \
--boot-disk-type=hyperdisk-balanced \
--machine-type $MACHINE_TYPE \
--image-family windows-2025 \
--image-project windows-cloud \
--zone $ZONE1 \
--subnet $SUBNET \
--scopes=compute-rw,trace,service-control,service-management,pubsub,monitoring-write,logging-write,storage-rw

Criar balanceador de carga interno

Reserve um endereço IP para o cluster e o balanceador de carga.

gcloud compute addresses create sqlfci-lb-ipaddress \
--region=$REGION \
--subnet=$SUBNET \
--purpose="SHARED_LOADBALANCER_VIP"
CLUSTER_ADDRESS=$(gcloud compute addresses describe sqlfci-lb-ipaddress \
--region $REGION \
--format=value\(address\)) && \
echo "Cluster IP address: $CLUSTER_ADDRESS"

Crie uma verificação de integridade para o cluster.

gcloud compute health-checks create tcp sqlfci-healthcheck \
--port="60008" \
--region=$REGION \
--check-interval=3 \
--timeout=2 \
--unhealthy-threshold=2 \
--healthy-threshold=5

Para permitir uma conexão com a porta de verificação de integridade, crie uma regra de firewall.

gcloud compute firewall-rules create "allow-sqlfci-healthcheck-60008" \
--allow "tcp:60008" \
--target-tags sqlfci \
--network $VPC_NAME \
--source-ranges="35.191.0.0/16,130.211.0.0/22" \
--priority="1000"

Para mais informações, consulte Regras de firewall para verificações de integridade.

Crie grupos de instâncias para os nós do cluster.

gcloud compute instance-groups unmanaged create sqlfci-1-uig \
--zone=$ZONE1
gcloud compute instance-groups unmanaged add-instances sqlfci-1-uig \
--zone=$ZONE1 \
--instances=node-1

gcloud compute instance-groups unmanaged create sqlfci-2-uig \
--zone=$ZONE2
gcloud compute instance-groups unmanaged add-instances sqlfci-2-uig \
--zone=$ZONE2 \
--instances=node-2

Crie o serviço de back-end do balanceador de carga.

gcloud compute backend-services create sqlfci-backend-services \
--region=$REGION \
--load-balancing-scheme="INTERNAL" \
--protocol="TCP" \
--health-checks=sqlfci-healthcheck \
--health-checks-region=$REGION

gcloud compute backend-services add-backend sqlfci-backend-services \
--region=$REGION \
--instance-group=sqlfci-1-uig \
--instance-group-zone=$ZONE1

gcloud compute backend-services add-backend sqlfci-backend-services \
--region=$REGION \
--instance-group=sqlfci-2-uig \
--instance-group-zone=$ZONE2

Crie a regra de encaminhamento do balanceador de carga.

gcloud compute forwarding-rules create "sqlfci-forwarding-rule" \
--load-balancing-scheme=INTERNAL \
--network=$VPC_NAME \
--subnet=$SUBNET \
--region=$REGION \
--address=$CLUSTER_ADDRESS \
--ip-protocol="TCP" \
--ports="ALL" \
--backend-service=sqlfci-backend-services \
--backend-service-region=$REGION

Crie um bucket do Cloud Storage para transferir arquivos dos nós de cluster primários para os secundários.
```
gcloud storage buckets create gs://BUCKET_NAME \
--location=$REGION \
--public-access-prevention
```
Substitua BUCKET_NAME pelo nome do bucket a ser criado.

Para mais informações, consulte Criar buckets.

Instalar o software necessário

Faça o download, instale e configure o mecanismo do SQL Server e o gerenciamento de cluster nas duas VMs do Linux, node-1 e node-2, que vão participar do cluster de failover.

Conecte-se a cada uma das VMs usando SSH. Para mais informações, consulte Conectar a VMs do Linux e Práticas recomendadas para controlar o acesso de rede SSH.
Atualize o hosts file em node-1 e node-2.

Observação: para uso em produção, a resolução de domínio precisa ser gerenciada por um servidor dedicado de Sistema de Nomes de Domínio (DNS).
1. Abra o hosts file para edição.
```
sudo vi /etc/hosts
```
2. Encontre o endereço IP interno de cada VM do Linux e anexe as entradas de host à parte inferior do arquivo.
  
  Acessar o Compute Engine
```
NODE1_INTERNAL_IP node-1
NODE2_INTERNAL_IP node-2
```
  Substitua NODE1_INTERNAL_IP e NODE2_INTERNAL_IP pelo endereço IP interno de cada VM do Linux.

Verifique a comunicação entre as VMs. Todas as VMs que participam do grupo de disponibilidade sempre ativado precisam conseguir se comunicar umas com as outras: volte a cada VM do Linux, execute os comandos de cada uma delas e verifique se todas podem se comunicar entre si.

ping -c 4 node-1
ping -c 4 node-2

A saída é semelhante a esta:

PING node-1 (10.128.0.37) 56(84) bytes of data.
64 bytes from node-1 (10.128.0.37): icmp_seq=1 ttl=128 time=1.91 ms
64 bytes from node-1 (10.128.0.37): icmp_seq=2 ttl=128 time=0.234 ms
64 bytes from node-1 (10.128.0.37): icmp_seq=3 ttl=128 time=0.249 ms
64 bytes from node-1 (10.128.0.37): icmp_seq=4 ttl=128 time=0.263 ms

Instale o SQL Server 2025.

Adicione o repositório do SQL Server ao sistema.

curl https://packages.microsoft.com/keys/microsoft.asc | sudo tee /etc/apt/trusted.gpg.d/microsoft.asc
curl -fsSL https://packages.microsoft.com/config/ubuntu/22.04/mssql-server-2025.list | sudo tee /etc/apt/sources.list.d/mssql-server-2025.list
sudo apt-get update

Instale o SQL Server.
```
sudo apt-get install -y mssql-server
```

Instale as ferramentas para desenvolvedores do SQL Server. Faça o download e instale as ferramentas do SQL Server nas duas VMs do Linux que vão participar do cluster de failover.

curl https://packages.microsoft.com/config/ubuntu/22.04/prod.list | sudo tee /etc/apt/sources.list.d/mssql-release.list
sudo apt-get update

sudo ACCEPT_EULA=Y apt-get install -y mssql-tools18 unixodbc-dev

Instale o Pacemaker. O Pacemaker é um software de gerenciamento de recursos de alta disponibilidade e de código aberto que é usado com o mecanismo de cluster Corosync. Nesta seção, você vai instalar o Pacemaker nas duas VMs do cluster.
1. Instale o Pacemaker em node-1 e node-2.
```
sudo apt-get install -y pacemaker pcs fence-agents resource-agents pacemaker-cli-utils crmsh
```
2. Instale o agente de recursos do SQL Server para o Pacemaker.
```
sudo apt-get install -y mssql-server-ha
```
Se houver um firewall ativado nas VMs, abra-o para o SQL Server.
1. Para verificar se Uncomplicated Firewall está instalado e ativado, execute o comando a seguir.
```
sudo ufw status
```
2. Se o status estiver ativo, execute os comandos a seguir para abrir as portas. Se o serviço de firewall não estiver em execução, ignore esta etapa.
```
sudo ufw allow 1433
sudo ufw allow 5022
sudo ufw reload
```
  Observação: se você estiver usando outras portas para o SQL Server ou para o endpoint do grupo de disponibilidade, mude as regras de firewall de acordo com isso.

Configurar o nó do banco de dados principal

Nesta seção, você vai inicializar os dois discos de vários gravadores e configurar cada um deles com grupos de volumes e grupos lógicos.

Configure o LVM.

Configure as configurações do LVM.

Faça backup da configuração atual.

sudo cp /etc/lvm/lvm.conf /etc/lvm/lvm.conf.bak

Atualizar a origem do ID do sistema:

sudo sed -i 's/^\(\s*system_id_source\s*=\s*\)"none"/\1"uname"/' /etc/lvm/lvm.conf

Verifique se a mudança foi feita corretamente.

grep 'system_id_source *= *"uname"' /etc/lvm/lvm.conf

Configure os grupos de volumes e volumes lógicos do LVM.

sudo pvcreate /dev/nvme0n2 /dev/nvme0n3
sudo pvs
sudo vgcreate vgdata /dev/nvme0n2
sudo lvcreate -l 100%FREE -n lvdata vgdata
sudo vgcreate vglogtmp /dev/nvme0n3
sudo lvcreate -l 70%FREE  -n lvlog vglogtmp
sudo lvcreate -l 100%FREE -n lvtmp vglogtmp
sudo vgs -o+systemid

Formate volumes com o sistema de arquivos xfs e tamanho de bloco de 64 KB.

sudo mkfs.xfs -d su=64k,sw=1 -L data /dev/vgdata/lvdata -f
sudo mkfs.xfs -d su=64k,sw=1 -L dblog /dev/vglogtmp/lvlog -f
sudo mkfs.xfs -d su=64k,sw=1 -L tmp /dev/vglogtmp/lvtmp -f

Verifique se os volumes foram criados.
```
sudo lvs
```

Ativar e formatar os discos

Configure pontos de montagem para os discos compartilhados e dê acesso ao usuário mssql.

Crie pontos de montagem para os novos volumes.

sudo mkdir /mssql
sudo mkdir -p /mssql/db_data
sudo mkdir -p /mssql/db_log
sudo mkdir -p /mssql/db_temp

Monte os volumes LVM em pontos de montagem.

sudo mount /dev/vgdata/lvdata /mssql/db_data
sudo mount /dev/vglogtmp/lvlog /mssql/db_log
sudo mount /dev/vglogtmp/lvtmp /mssql/db_temp

Defina o usuário mssql como proprietário dos pontos de montagem.

sudo chown mssql:mssql /mssql/db_data
sudo chown mssql:mssql /mssql/db_log
sudo chown mssql:mssql /mssql/db_temp

Configure o SQL Server:
1. Defina variáveis realocando o banco de dados principal para o armazenamento compartilhado e execute a ferramenta mssql-conf.
```
sudo MSSQL_MASTER_DATA_FILE="/mssql/db_data/master.mdf" MSSQL_MASTER_LOG_FILE="/mssql/db_data/mastlog.ldf" /opt/mssql/bin/mssql-conf setup
```
2. Escolha a edição Developer para o SQL Server e aceite o contrato de licença.
  
  A edição Developer inclui todos os recursos empresariais, mas só pode ser usada em ambientes que não sejam de produção. Saiba mais sobre as edições do SQL Server e as licenças da Microsoft.
  
  Observação: para cada instância de VM, é necessária uma licença do SQL Server. Ao executar servidores de aplicativos da Microsoft, a Mobilidade de Licenças via Software Assurance ajuda na transição para o Google Cloud. Para mais informações, consulte Como usar a mobilidade de licença com aplicativos de servidor da Microsoft. Se você não tiver sua própria licença e precisar comprar uma pelo Google (PAYG), siga as etapas em Adicionar uma licença do SQL Server a um disco de inicialização para comprar uma licença para cada instância de VM.
3. Especifique uma senha para a conta da SA.
4. Verifique se o serviço mssql-server está sendo executado.
```
systemctl status mssql-server --no-pager
```

Configurar o SQL Server e o Pacemaker

Crie um usuário do SQL Server para o Pacemaker. Substitua SA_PASSWORD pela senha da conta SA no SQL Server e PA_PASSWORD pela senha que será usada na conta pacemaker.

QUERY="
CREATE LOGIN [pacemaker] with PASSWORD= N'PA_PASSWORD';
ALTER SERVER ROLE [sysadmin] ADD MEMBER [pacemaker];
GO"

/opt/mssql-tools18/bin/sqlcmd -No -S localhost -U sa -P 'SA_PASSWORD' -Q "$QUERY"

Adicione o nome de usuário e a senha do Pacemaker à pasta de secrets do SQL Server.

{
  echo 'pacemaker'
  echo PA_PASSWORD'
} | sudo tee /var/opt/mssql/secrets/passwd > /dev/null
sudo chown root:root /var/opt/mssql/secrets/passwd
sudo chmod 400 /var/opt/mssql/secrets/passwd

Atualize a configuração do SQL Server para usar os novos locais de dados, registros e temporários. Você também vai definir as configurações recomendadas do SQL Server.

sudo /opt/mssql/bin/mssql-conf set filelocation.defaultdatadir /mssql/db_data
sudo /opt/mssql/bin/mssql-conf set filelocation.defaultlogdir /mssql/db_log
sudo /opt/mssql/bin/mssql-conf set filelocation.defaultdumpdir /mssql/db_log
sudo /opt/mssql/bin/mssql-conf traceflag 9944 3979 on
sudo /opt/mssql/bin/mssql-conf set control.alternatewritethrough 0
sudo /opt/mssql/bin/mssql-conf set control.writethrough 1

Mover TempDB para disco compartilhado

Receba a lista de arquivos TempDB e use-os para criar uma consulta de alteração. Essa consulta será usada na próxima etapa para definir o novo local dos arquivos TempDB.

QUERY="
SET NOCOUNT ON;
SELECT 'ALTER DATABASE tempdb MODIFY FILE (NAME = [' + f.name + '],' + ' FILENAME = ''/mssql/db_temp/' + f.name + CASE WHEN f.type = 1 THEN '.ldf' ELSE '.mdf' END + ''');' FROM sys.master_files f WHERE f.database_id = DB_ID(N'tempdb');"

/opt/mssql-tools18/bin/sqlcmd -No -S localhost -U sa -P 'SA_PASSWORD' -Q "$QUERY"

Capture a saída do comando anterior. Você vai usar a saída para formar o próximo comando a ser executado.

QUERY="QUERY_OUTPUT"

Exemplo de consulta usando a saída:

QUERY="
ALTER DATABASE tempdb MODIFY FILE (NAME = [tempdev], FILENAME = '/mssql/db_temp/tempdev.mdf');
ALTER DATABASE tempdb MODIFY FILE (NAME = [templog], FILENAME = '/mssql/db_temp/templog.ldf');
ALTER DATABASE tempdb MODIFY FILE (NAME = [tempdev2], FILENAME = '/mssql/db_temp/tempdev2.mdf');
ALTER DATABASE tempdb MODIFY FILE (NAME = [tempdev3], FILENAME = '/mssql/db_temp/tempdev3.mdf');"

Execute o comando SQL gerado para mover os arquivos TempDB.

/opt/mssql-tools18/bin/sqlcmd -No -S localhost -U sa -P 'SA_PASSWORD' -Q "$QUERY"

Reinicie o serviço do SQL Server para que as mudanças entrem em vigor.
```
sudo systemctl restart mssql-server.service
```
Verifique se os arquivos TempDB foram criados.
```
ls -l /mssql/db_temp/
```
Verifique se o serviço do SQL Server está em execução.
```
systemctl status mssql-server --no-pager
```

Configurar o HAProxy

Defina uma nova senha para o hacluster.

Observação: defina a mesma senha nos três nós. Você vai precisar dessa senha ao configurar o cluster.
```
sudo passwd hacluster
```
Para concluir a configuração e testar se o balanceador de carga de rede está configurado corretamente, instale e configure o HAProxy tcp listener nos dois nós do cluster:
1. Instale o HAProxy.
```
sudo apt-get install haproxy
```
2. Digite Y para concluir a instalação.
3. Edite o arquivo haproxy.cfg.
```
sudo vi /etc/haproxy/haproxy.cfg
```
4. Na seção defaults do haproxy.cfg file, mude o modo para tcp.
5. Anexe a seguinte seção ao final do arquivo haproxy.cfg.
```
#---------------------------------------------------------------
# Set up health check listener for SQL Server Availability Group
#---------------------------------------------------------------
listen healthcheck
bind *:60008
```

Inicie o serviço do HAProxy.

sudo systemctl start haproxy.service
sudo systemctl status haproxy.service

Interrompa e desative o serviço HAProxy.

sudo systemctl stop haproxy.service
sudo systemctl disable haproxy.service

Faça upload do arquivo de chave da máquina para o Cloud Storage usando o comando a seguir.
```
sudo gcloud storage cp /var/opt/mssql/secrets/machine-key gs://BUCKET_NAME/
```
Substitua BUCKET_NAME pelo nome do bucket criado.
Pare e desative o serviço do SQL Server. O serviço a partir desse ponto será controlado pelo cluster.
```
sudo systemctl stop mssql-server.service
sudo systemctl disable mssql-server.service
```

Desconecte o armazenamento compartilhado.

sudo umount /mssql/db_data
sudo umount /mssql/db_log
sudo umount /mssql/db_temp

Limpe a configuração padrão do cluster atual.
```
sudo pcs cluster destroy
```

Configurar o nó secundário

Crie pontos de montagem para os volumes do LVM. Não é necessário formatar o disco porque ele é compartilhado com node-1. Você já formatou o disco e configurou os volumes LVM ao configurar node-1.

sudo mkdir /mssql
sudo mkdir -p /mssql/db_data
sudo mkdir -p /mssql/db_log
sudo mkdir -p /mssql/db_temp

sudo chown mssql:mssql /mssql/db_data
sudo chown mssql:mssql /mssql/db_log
sudo chown mssql:mssql /mssql/db_temp

Configure o SQL Server.
1. Para realocar o banco de dados principal no disco de dados compartilhados, defina as seguintes variáveis e execute a ferramenta mssql-conf para aplicar as mudanças.
```
sudo MSSQL_MASTER_DATA_FILE="/mssql/db_data/master.mdf" MSSQL_MASTER_LOG_FILE="/mssql/db_data/mastlog.ldf" /opt/mssql/bin/mssql-conf setup
```
2. Escolha a edição Developer para o SQL Server e aceite o contrato de licença.
  
  A edição Developer inclui todos os recursos empresariais, mas só pode ser usada em ambientes que não sejam de produção. Saiba mais sobre as edições do SQL Server e as licenças da Microsoft.
  
  Observação: é necessário ter uma licença do SQL Server para cada instância. Ao executar servidores de aplicativos da Microsoft, a Mobilidade de Licenças via Software Assurance ajuda na transição para o Google Cloud. Para mais informações, consulte Como usar a mobilidade de licença com aplicativos de servidor da Microsoft. Se você não tiver sua própria licença e precisar comprar uma pelo Google (PAYG), siga as etapas em Adicionar uma licença do SQL Server a um disco de inicialização para comprar uma licença para cada instância de VM.
3. Especifique uma senha para a conta da SA.
4. Verifique se o serviço mssql-server está sendo executado.
```
systemctl status mssql-server --no-pager
```

Crie um usuário do SQL Server para o cluster do Pacemaker. Substitua SA_PASSWORD pela senha da conta SA no SQL Server e PA_PASSWORD pela senha que será usada na conta pacemaker.

QUERY="
CREATE LOGIN [pacemaker] with PASSWORD= N'PA_PASSWORD';
ALTER SERVER ROLE [sysadmin] ADD MEMBER [pacemaker];
GO"

/opt/mssql-tools18/bin/sqlcmd -No -S localhost -U sa -P 'SA_PASSWORD' -Q "$QUERY"

Adicione o nome de usuário e a senha do Pacemaker à pasta de secrets do SQL Server.

{
  echo 'pacemaker'
  echo 'PA_PASSWORD'
} | sudo tee /var/opt/mssql/secrets/passwd > /dev/null
sudo chown root:root /var/opt/mssql/secrets/passwd
sudo chmod 400 /var/opt/mssql/secrets/passwd

Atualize a configuração do SQL Server para usar os novos locais de dados, registros e temporários. Você também vai definir as configurações recomendadas do SQL Server.

sudo /opt/mssql/bin/mssql-conf set filelocation.defaultdatadir /mssql/db_data
sudo /opt/mssql/bin/mssql-conf set filelocation.defaultlogdir /mssql/db_log
sudo /opt/mssql/bin/mssql-conf set filelocation.defaultdumpdir /mssql/db_log
sudo /opt/mssql/bin/mssql-conf traceflag 9944 3979 on
sudo /opt/mssql/bin/mssql-conf set control.alternatewritethrough 0
sudo /opt/mssql/bin/mssql-conf set control.writethrough 1

Mova a TempDB para o disco de dados compartilhado.

Receba a lista de arquivos TempDB e use-os para criar a consulta "Alter".

QUERY="
SET NOCOUNT ON;
SELECT 'ALTER DATABASE tempdb MODIFY FILE (NAME = [' + f.name + '],' + ' FILENAME = ''/mssql/db_temp/' + f.name + CASE WHEN f.type = 1 THEN '.ldf' ELSE '.mdf' END + ''');' FROM sys.master_files f WHERE f.database_id = DB_ID(N'tempdb');"

/opt/mssql-tools18/bin/sqlcmd -No -S localhost -U sa -P 'SA_PASSWORD' -Q "$QUERY"

Capture a saída do comando anterior. Você vai usar a saída para formar o próximo comando a ser executado.

QUERY="QUERY_OUTPUT"

Exemplo de consulta usando a saída:

QUERY="
ALTER DATABASE tempdb MODIFY FILE (NAME = [tempdev], FILENAME = '/mssql/db_temp/tempdev.mdf');
ALTER DATABASE tempdb MODIFY FILE (NAME = [templog], FILENAME = '/mssql/db_temp/templog.ldf');
ALTER DATABASE tempdb MODIFY FILE (NAME = [tempdev2], FILENAME = '/mssql/db_temp/tempdev2.mdf');
ALTER DATABASE tempdb MODIFY FILE (NAME = [tempdev3], FILENAME = '/mssql/db_temp/tempdev3.mdf');"

Para mover os arquivos TempDB, execute o comando SQL gerado.

/opt/mssql-tools18/bin/sqlcmd -No -S localhost -U sa -P 'SA_PASSWORD' -Q "$QUERY"

Para que as mudanças entrem em vigor, reinicie o serviço do SQL Server.
```
sudo systemctl restart mssql-server.service
```
Verifique se o serviço do SQL Server está em execução.
```
sudo systemctl status mssql-server --no-pager
```
Verifique se os arquivos TempDB foram criados.
```
ls -l /mssql/db_temp/
```

Interrompa e desative temporariamente o serviço do SQL Server.

sudo systemctl stop mssql-server.service
sudo systemctl disable mssql-server.service

Para garantir que os dois nós usem a mesma chave para o SQL Server, faça o download do arquivo de chave da máquina em node-1.

sudo rm /var/opt/mssql/secrets/machine-key
sudo gcloud storage cp gs://BUCKET_NAME/machine-key /var/opt/mssql/secrets/machine-key
sudo chown mssql:mssql /var/opt/mssql/secrets/machine-key
sudo chmod 0600  /var/opt/mssql/secrets/machine-key

Defina as configurações do LVM.

Faça backup da configuração atual.

sudo cp /etc/lvm/lvm.conf /etc/lvm/lvm.conf.bak

Atualizar a origem do ID do sistema.

sudo sed -i 's/^\(\s*system_id_source\s*=\s*\)"none"/\1"uname"/' /etc/lvm/lvm.conf

Verifique a mudança executando:

cat /etc/lvm/lvm.conf | grep uname

A saída é semelhante a esta:

#     Set the system ID from the hostname (uname) of the system.
system_id_source = "uname"

Verifique se a mudança foi feita com sucesso.

grep 'system_id_source *= *"uname"' /etc/lvm/lvm.conf

Defina uma nova senha para o hacluster.

Observação: defina a mesma senha nos dois nós. Essa senha será necessária durante a configuração do cluster.
```
sudo passwd hacluster
```
Para concluir a configuração e testar se o balanceador de carga de rede está configurado corretamente, instale e configure o HAProxy tcp listener nos dois nós do cluster.
1. Instale o HAProxy.
```
sudo apt-get install haproxy
```
2. Escolha Y para concluir a instalação.
3. Edite o arquivo haproxy.cfg.
```
sudo vi /etc/haproxy/haproxy.cfg
```
4. Na seção de padrões de haproxy.cfg file, mude o modo para tcp.
5. Anexe a seguinte seção ao final do arquivo haproxy.cfg.
```
#---------------------------------------------------------------
# Set up health check listener for SQL Server Availability Group
#---------------------------------------------------------------
listen healthcheck
bind *:60008
```
6. Inicie o serviço do HAProxy.
```
sudo systemctl start haproxy.service
sudo systemctl status haproxy.service
```

Interrompa e desative o serviço HAProxy.

sudo systemctl stop haproxy.service
sudo systemctl disable haproxy.service

Limpe a configuração padrão do cluster atual.
```
sudo pcs cluster destroy
```

Conclua a configuração do cluster

Volte para node-1 para continuar a configuração do cluster.

Faça a autenticação como o usuário hacluster.

sudo pcs host auth node-1 node-2 -u hacluster -p "HA_PASSWORD"

Crie um cluster chamado ubuntu_fci.

sudo pcs cluster setup ubuntu_fci node-1 addr="NODE1_INTERNAL_IP" node-2 addr="NODE2_INTERNAL_IP" --start --enable

Defina no-quorum-policy para um cluster de dois nós.
```
sudo pcs property set no-quorum-policy="ignore"
```

Crie um recurso de cluster de endereço IP virtual.

sudo pcs resource create pcs-cluster-vip ocf:heartbeat:IPaddr2 ip="CLUSTER_ADDRESS" cidr_netmask=32 nic=ens3 op monitor interval=30s

Substitua CLUSTER_ADDRESS pelo endereço IP reservado anteriormente.

Crie objetos de recursos de cluster para todos os volumes compartilhados.

sudo pcs resource create vgdata ocf:heartbeat:LVM-activate vgname=vgdata vg_access_mode=system_id activation_mode=exclusive
sudo pcs resource create vglogtmp ocf:heartbeat:LVM-activate vgname=vglogtmp vg_access_mode=system_id activation_mode=exclusive
sudo pcs resource create data_dir ocf:heartbeat:Filesystem device="/dev/mapper/vgdata-lvdata" directory="/mssql/db_data" fstype="xfs"
sudo pcs resource create log_dir ocf:heartbeat:Filesystem device="/dev/mapper/vglogtmp-lvlog" directory="/mssql/db_log" fstype="xfs"
sudo pcs resource create tmp_dir ocf:heartbeat:Filesystem device="/dev/mapper/vglogtmp-lvtmp" directory="/mssql/db_temp" fstype="xfs"

Crie um grupo de recursos e adicione todos os objetos criados a ele.

sudo pcs resource group add sql_group pcs-cluster-vip vgdata vglogtmp data_dir log_dir tmp_dir

Crie o recurso de cluster para o serviço do Microsoft SQL Server e adicione-o ao grupo de recursos atual.
```
sudo pcs resource create sql_fci ocf:mssql:fci  op stop timeout=60s --group sql_group
```

Crie um recurso de cluster para o HAProxy e adicione-o ao mesmo grupo.

sudo pcs resource create pcs-healthcheck systemd:haproxy.service op monitor interval=20s timeout=30s --group sql_group

Crie uma restrição de cluster que controle a sequência de inicialização dos recursos.

sudo pcs constraint order set  pcs-cluster-vip vgdata vglogtmp data_dir log_dir tmp_dir sql_fci pcs-healthcheck

Configurar um isolamento STONITH

O STONITH é uma estratégia de isolamento para manter a integridade dos nós em um cluster de HA. O serviço STONITH funciona no nível do nó e protege o cluster contra nós que não respondem ou estão em um estado desconhecido. Recomendamos o dispositivo de isolamento fence_gce especializado para o Compute Engine em Google Cloud.

Configurar dispositivos de isolamento

Verifique se o agente de isolamento fence_gce do Compute Engine está instalado em node-1.
```
sudo pcs stonith list | grep fence_gce
```
Para mais informações, consulte:
- Agente de isolamento para o Google Compute Engine.
- Para conferir os parâmetros associados ao agente, execute o seguinte comando:
```
sudo pcs stonith describe fence_gce
```

Configure recursos de isolamento de cluster.

sudo pcs stonith create node-1-fence fence_gce \
plug=node-1 \
zone=ZONE1 \
project=PROJECT_ID \
pcmk_reboot_timeout=300 pcmk_monitor_retries=4 pcmk_delay_max=30 \
op monitor interval="300s" timeout="120s" \
op start interval="0" timeout="60s"

sudo pcs stonith create node-2-fence fence_gce \
plug=node-2 \
zone=ZONE2 \
project=PROJECT_ID \
pcmk_reboot_timeout=300 pcmk_monitor_retries=4 pcmk_delay_max=30 \
op monitor interval="300s" timeout="120s" \
op start interval="0" timeout="60s"

Substitua ZONE1 e ZONE2 pela zona em que as VMs do Linux foram implantadas e PROJECT_ID pelo ID do projeto.

É possível testar o status dos agentes de isolamento executando o comando status.
```
sudo fence_gce -o status -n node-1 --zone=ZONE1
sudo fence_gce -o status -n node-2 --zone=ZONE2
```
A saída é semelhante a esta:
```
Status: ON
```

Substitua ZONE1 e ZONE2 pela zona em que as VMs do Linux foram implantadas.

Crie restrições de local para os dispositivos de isolamento para garantir que eles sejam executados apenas nas instâncias pretendidas.
```
sudo pcs constraint location node-1-fence avoids node-1
sudo pcs constraint location node-2-fence avoids node-2
```

Ative o isolamento no cluster do Pacemaker e defina o tempo limite de isolamento do cluster.

sudo pcs -f stonith_cfg property set stonith-enabled=true
sudo pcs property set stonith-timeout="300s"

Limpe o processo de inicialização do cluster.
```
sudo pcs resource cleanup
```

Verifique o status do cluster.

sudo crm status

A saída é semelhante a esta:

  Cluster Summary:
    * Stack: corosync
    * Current DC: node-1 (version 2.1.2-ada5c3b36e2) - partition with quorum
    * Last updated: Tue Jun  2 21:36:47 2026
    * Last change:  Mon Apr 27 12:31:58 2026 by root via crm_resource on node-1
    * 2 nodes configured
    * 10 resource instances configured

  Node List:
    * Online: [ node-1 node-2 ]

  Full List of Resources:
    * Resource Group: sql_group:
      * pcs-cluster-vip   (ocf:heartbeat:IPaddr2):         Started node-2
      * vgdata    (ocf:heartbeat:LVM-activate):    Started node-2
      * vglogtmp  (ocf:heartbeat:LVM-activate):    Started node-2
      * data_dir  (ocf:heartbeat:Filesystem):      Started node-2
      * log_dir   (ocf:heartbeat:Filesystem):      Started node-2
      * tmp_dir   (ocf:heartbeat:Filesystem):      Started node-2
      * sql_fci   (ocf:mssql:fci):                 Started node-2
      * pcs-healthcheck   (systemd:haproxy.service):       Started node-2
    * node-1-fence       (stonith:fence_gce):     Started node-2
    * node2-fence        (stonith:fence_gce):     Started node-1

Testar dispositivos de isolamento

Após a configuração dos dispositivos de isolamento, teste-os seguindo as etapas abaixo.

Interrompa o isolamento em node-2.

Conecte-se a node-1 e execute o comando a seguir para testar o dispositivo de isolamento associado a node-2 no cluster.
```
fence_gce -o off -n node-2 --zone=ZONE2
```
A saída é semelhante a esta:
```
Success: Powered OFF
```
Verifique o status do cluster.
```
sudo crm status
```
A saída é semelhante a esta:

    Cluster Summary:
      * Stack: corosync
      * Current DC: node-1 (version 2.1.2-ada5c3b36e2) - partition with quorum
      * Last updated: Tue Jun  2 21:52:00 2026
      * Last change:  Mon Apr 27 12:31:58 2026 by root via crm_resource on node-1
      * 2 nodes configured
      * 10 resource instances configured

    Node List:
      * Online: [ node-1 ]
      * OFFLINE: [ node-2 ]

    Full List of Resources:
      * Resource Group: sql_group:
        * pcs-cluster-vip   (ocf:heartbeat:IPaddr2): Started node-1
        * vgdata    (ocf:heartbeat:LVM-activate):    Started node-1
        * vglogtmp  (ocf:heartbeat:LVM-activate):    Started node-1
        * data_dir  (ocf:heartbeat:Filesystem):      Started node-1
        * log_dir   (ocf:heartbeat:Filesystem):      Started node-1
        * tmp_dir   (ocf:heartbeat:Filesystem):      Started node-1
        * sql_fci   (ocf:mssql:fci):                 Started node-1
        * pcs-healthcheck   (systemd:haproxy.service):       Started node-1
      * node-1-fence       (stonith:fence_gce):     Stopped
      * node-2-fence        (stonith:fence_gce):     Started node-1

Observe também que node-2 está desativado no Compute Engine.

Acessar o Compute Engine

Reinicie o isolamento em node-2.
1. Retorne a node-1 e reinicie a instância novamente executando o comando a seguir.
```
fence_gce -o on -n node-2 --zone=ZONE2
```
  A saída é semelhante a esta:
```
Success: Powered ON
```
2. Verifique o status do cluster no Pacemaker e no Compute Engine. Depois de um curto período, você vai notar que node-2 está novamente on-line.
```
 $ sudo crm status
```

Testar o failover

Agora está tudo pronto para testar se o failover funciona corretamente.

Crie um nome de usuário e uma senha para a instância de VM.
Conecte-se à VM usando a Área de trabalho remota e faça login usando o nome de usuário e a senha criados na etapa anterior.
Conecte-se à VM do Windows em cl-node pela Área de trabalho remota.
Abra uma sessão do PowerShell.

Conecte-se ao servidor executando o script a seguir. A cada cinco segundos, o script se conecta ao SQL Server usando o listener do grupo de disponibilidade e consulta o nome do servidor.

while ($True){
  try {
    $Conn = New-Object System.Data.SqlClient.SqlConnection
    $Conn.ConnectionString = "Server=CLUSTER_ADDRESS;User ID=sa;Password=SA_PASSWORD;Initial Catalog=master"
    $Conn.Open()

    $Cmd =  $Conn.CreateCommand()
    $Cmd.CommandText = "SELECT SERVERPROPERTY('ComputerNamePhysicalNetBIOS')"

    $Result = $Cmd.ExecuteReader()
    if ($Result.Read()) {
      $currentNode = $Result.GetString(0)
      Write-Host "Current Node: $currentNode at $(Get-Date)"
    }

    $Conn.Close()
    Start-Sleep -Seconds 5
  }
  catch {
      Write-Host "SQL Connection Failed at $(Get-Date). Retrying..."
      Start-Sleep -Seconds 15 # Wait before retrying
  }
}

Substitua CLUSTER_ADDRESS pelo endereço IP do listener e SA_PASSWORD pela senha da conta de SA no SQL Server.

A saída é semelhante a esta:

  Current Node: node-1 at 06/09/2026 20:24:35
  Current Node: node-1 at 06/09/2026 20:24:40
  Current Node: node-1 at 06/09/2026 20:24:45
  Current Node: node-1 at 06/09/2026 20:24:50
  Current Node: node-1 at 06/09/2026 20:24:55

Deixe o script em execução.

Acione um failover para node-2: em node-1, volte ao terminal SSH e execute o seguinte comando.
```
sudo pcs resource move sql_group node-2
```

Volte para a sessão do PowerShell em cl-node.

Observe a saída do script em execução e veja que o nome do servidor mudou de node-1 para node-2 como resultado do failover.

A saída é semelhante a esta:

  Current Node: node-1 at 06/09/2026 20:28:51
  Current Node: node-1 at 06/09/2026 20:28:56
  SQL Connection Failed at 06/09/2026 20:29:16. Retrying...
  Current Node: node-2 at 06/09/2026 20:29:31
  Current Node: node-2 at 06/09/2026 20:29:36

Inicie um failback para node-1. Na linha de comando do node-1, execute o seguinte comando:
```
sudo pcs resource move sql_group node-1
```
Volte para o PowerShell em cl-node. Para interromper o script, pressione Ctrl+C.

Limpar

Depois de concluir o tutorial, você pode limpar os recursos que criou para que eles parem de usar a cota e gerar cobranças. Nas seções a seguir, você aprenderá a excluir e desativar esses recursos.

Excluir o projeto

O jeito mais fácil de evitar cobranças é excluindo o projeto que você criou para o tutorial.

Para excluir o projeto:

No console Google Cloud , acesse a página Gerenciar recursos.
Acessar "Gerenciar recursos"
Na lista de projetos, selecione o projeto que você quer excluir e clique em Excluir .
Na caixa de diálogo, digite o ID do projeto e clique em Encerrar para excluí-lo.

Como configurar uma instância de cluster de failover do SQL Server no Linux com um disco de vários gravadores Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Benefícios de implementar alta disponibilidade com discos de vários gravadores

Principais destaques desta arquitetura

Objetivos

Custos

Antes de começar

Preparar o projeto e a rede

Criar os nós do cluster

Criar balanceador de carga interno

Instalar o software necessário

Configurar o nó do banco de dados principal

Configure o LVM.

Ativar e formatar os discos

Configurar o SQL Server e o Pacemaker

Mover TempDB para disco compartilhado

Configurar o HAProxy

Configurar o nó secundário

Conclua a configuração do cluster

Configurar um isolamento STONITH

Configurar dispositivos de isolamento

Testar dispositivos de isolamento

Testar o failover

Limpar

Excluir o projeto

A seguir

Como configurar uma instância de cluster de failover do SQL Server no Linux com um disco de vários gravadores