Teste de carga do SQL Server usando HammerDB

Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Configurando a instância do SQL Server para teste de carga

Antes de começar, você deve verificar se as regras de firewall do Windows estão configuradas para permitir o tráfego do endereço IP da nova instância do Windows que você criou. Em seguida, crie um novo banco de dados para teste de carga TPCC e configure uma conta de usuário usando as seguintes etapas:

1. Clique com o botão direito na pasta Bancos de Dados no SQL Server Management Studio e escolha Novo Banco de Dados .
2. Nomeie o novo banco de dados como "TPCC".
3. Defina o tamanho inicial do arquivo de dados para 190.000 MB e o arquivo de log para 65.000 MB.

4. Defina os limites de crescimento automático para valores mais altos clicando nos botões de reticências, conforme mostrado na captura de tela a seguir:

   

5. Defina o arquivo de dados para aumentar em 64 MB até um tamanho ilimitado.

6. Defina o arquivo de log para desativar o crescimento automático.

7. Clique em OK .

8. Na caixa de diálogo Novo banco de dados , no painel esquerdo, escolha a página Opções .

9. Defina o nível de compatibilidade para SQL Server 2022 (160) .

10. Defina o modelo de recuperação como Simple , para que o carregamento não preencha os logs de transações.

    

11. Clique em OK para criar o banco de dados TPCC, o que pode levar alguns minutos para ser concluído.

12. A imagem pré-configurada do SQL Server vem apenas com a autenticação do Windows habilitada, portanto, você precisará habilitar a autenticação de modo misto no SSMS, seguindo este guia .

13. Siga estas etapas para criar uma nova conta de usuário do SQL Server no servidor de banco de dados que tenha a permissão DBOwner. Nomeie a conta como "loaduser" e forneça uma senha segura.

14. Anote o endereço IP interno do SQL Server usando o comando Get-NetIPAddress , pois é importante para o desempenho e a segurança usar o IP interno.

Instalando o HammerDB

Você pode executar o HammerDB diretamente na sua instância do SQL Server. No entanto, para um teste mais preciso, crie uma nova instância do Windows e teste a instância do SQL Server remotamente.

Criando uma instância

Siga estas etapas para criar uma nova instância do Compute Engine:

1. No console do Google Cloud, acesse a página Criar uma instância .

   Vá para Criar uma instância

2. Para Nome , insira hammerdb-instance .

3. Na seção Configuração da máquina , selecione o tipo de máquina com pelo menos metade do número de CPUs da sua instância de banco de dados.

4. Na seção Disco de inicialização , clique em Alterar e faça o seguinte:

   1. Na guia Imagens públicas , escolha um sistema operacional Windows Server.
   2. Na lista Versão , clique em Windows Server 2022 Datacenter .
   3. Na lista Tipo de disco de inicialização , selecione Disco permanente padrão .
   4. Para confirmar as opções do disco de inicialização, clique em Selecionar .

5. Para criar e iniciar a VM, clique em Criar .

Instalando o software

Quando estiver pronto, use um cliente RDP para conectar-se à sua nova instância do Windows Server e instale o seguinte software:

• Driver ODBC 18 para SQL Server
• HammerDB para Windows de 64 bits

Executando o HammerDB

Depois de instalar o HammerDB, execute o arquivo hammerdb.bat . HammberDB não aparece na lista de aplicativos do menu Iniciar. Use o seguinte comando para executar o HammerDB:

C:\Program Files\HammerDB-VERSION\hammerdb.bat

Substitua VERSION pela versão do HammerDB instalado.

Criando a conexão e o esquema

Quando o aplicativo está em execução, a primeira etapa é configurar a conexão para construir o esquema.

1. Clique duas vezes em SQL Server no painel Benchmark .
2. Selecione TPROC-C . Do site HammerDB :

   TPROC-C é a carga de trabalho OLTP implementada no HammerDB derivada da especificação TPROC-C com modificação para tornar a execução do HammerDB simples e econômica em qualquer um dos ambientes de banco de dados suportados. A carga de trabalho HammerDB TPROC-C é uma carga de trabalho de código aberto derivada do TPROC-C Benchmark Standard e, como tal, não é comparável aos resultados publicados do TPROC-C, pois os resultados estão em conformidade com um subconjunto em vez do TPROC-C Benchmark Standard completo. O nome da carga de trabalho HammerDB TPROC-C significa "Benchmark de processamento de transações derivado da especificação TPC "C"".

3. Clique em OK

   

4. Clique em Esquema e clique duas vezes em Opções .

5. Preencha o formulário usando seu endereço IP, nome de usuário e senha conforme mostrado na imagem a seguir:

   

6. Defina o driver ODBC do SQL Server como driver OBDC 18 para SQL Server

7. Neste caso, o Número de Armazéns (escala) é definido como 460, mas você pode escolher um valor diferente. Algumas diretrizes sugerem de 10 a 100 armazéns por CPU. Para este tutorial, defina esse valor como 10 vezes o número de núcleos: 160 para uma instância de 16 núcleos.

8. Para Virtual Users to Build Schema , escolha um número que esteja entre 1 e 2 vezes o número de vCPUs do cliente. Você pode clicar na barra cinza ao lado do controle deslizante para aumentar o número.

9. Desmarque a opção Usar BPC

10. Clique em OK

11. Clique duas vezes na opção Build abaixo da seção Schema Build para criar o esquema e carregar as tabelas. Quando isso for concluído, clique no ícone de luz vermelha do flash na parte superior central da tela para destruir o usuário virtual e passar para a próxima etapa.

Se você criou seu banco de dados com o modelo de recuperação Simple , talvez queira alterá-lo novamente para Full neste momento para obter um teste mais preciso de um cenário de produção. Isso não entrará em vigor até que você faça um backup completo ou diferencial para acionar o início da nova cadeia de logs.

Criando o script do driver

HammerDB usa o script de driver para orquestrar o fluxo de instruções SQL para o banco de dados para gerar a carga necessária.

1. No painel Benchmark , expanda a seção Driver Script e clique duas vezes em Options .
2. Verifique se as configurações correspondem ao que você usou na caixa de diálogo Criação de esquema .
3. Escolha Script de driver cronometrado .
4. A opção Checkpoint quando concluído força o banco de dados a gravar tudo no disco no final do teste, portanto, marque isso apenas se você planeja executar vários testes consecutivos.
5. Para garantir um teste completo, defina Minutos de tempo de aceleração como 5 e Minutos de duração do teste como 20.
6. Clique em OK para sair da caixa de diálogo.
7. Clique duas vezes em Carregar na seção Driver Script do painel Benchmark para ativar o script do driver.

Criando usuários virtuais

A criação de uma carga realista normalmente requer a execução de scripts como vários usuários diferentes. Crie alguns usuários virtuais para o teste.

1. Expanda a seção Usuários Virtuais e clique duas vezes em Opções .
2. Se você definir a contagem (escala) do armazém como 160, defina os Usuários Virtuais como 16, porque as diretrizes do TPROC-C recomendam uma proporção de 10x para evitar o bloqueio de linha. Marque a caixa de seleção Mostrar saída para ativar mensagens de erro no console.
3. Clique em OK

Coletando estatísticas de tempo de execução

O HammerDB e o SQL Server não coletam facilmente estatísticas detalhadas de tempo de execução para você. Embora as estatísticas estejam disponíveis no SQL Server, elas precisam ser capturadas e calculadas regularmente. Se você ainda não possui um procedimento ou ferramenta para ajudar a capturar esses dados, você pode usar o procedimento abaixo para capturar algumas métricas úteis durante o teste. Os resultados serão gravados em um arquivo CSV no diretório temp do Windows. Você pode copiar os dados para uma planilha do Google usando a opção Colar especial > Colar CSV .

Para usar esse procedimento, primeiro você deve ativar temporariamente os Procedimentos de Automação OLE para gravar o arquivo no disco. Lembre-se de desativá-lo após o teste:

sp_configure 'show advanced options', 1;
GO
RECONFIGURE;
GO
sp_configure 'Ole Automation Procedures', 1;
GO
RECONFIGURE;
GO

Aqui está o código para criar o procedimento sp_write_performance_counters no SQL Server Management Studio. Antes de iniciar o teste de carga, você executará este procedimento no Management Studio.:

USE [master]
GO

SET ANSI_NULLS ON
GO

SET QUOTED_IDENTIFIER ON
GO

/***
LogFile path has to be in a directory that SQL Server can Write To.
*/
CREATE PROCEDURE [dbo].[sp_write_performance_counters] @LogFile varchar (2000) = 'C:\\WINDOWS\\TEMP\\sqlPerf.log', @SecondsToRun int =1600, @RunIntervalSeconds int = 2

AS

BEGIN
--File writing variables
DECLARE @OACreate INT, @OAFile INT, @FileName VARCHAR(2000), @RowText VARCHAR(500), @Loops int, @LoopCounter int, @WaitForSeconds varchar (10)
--Variables to save last counter values
DECLARE @LastTPS BIGINT, @LastLRS BIGINT, @LastLTS BIGINT, @LastLWS BIGINT, @LastNDS BIGINT, @LastAWT BIGINT, @LastAWT_Base BIGINT, @LastALWT BIGINT, @LastALWT_Base BIGINT
--Variables to save current counter values
DECLARE @TPS BIGINT, @Active BIGINT, @SCM BIGINT, @LRS BIGINT, @LTS BIGINT, @LWS BIGINT, @NDS BIGINT, @AWT BIGINT, @AWT_Base BIGINT, @ALWT BIGINT, @ALWT_Base BIGINT, @ALWT_DIV BIGINT, @AWT_DIV BIGINT

SELECT @Loops = case when (@SecondsToRun % @RunIntervalSeconds) > 5 then @SecondsToRun / @RunIntervalSeconds + 1 else @SecondsToRun / @RunIntervalSeconds end
SET @LoopCounter = 0
SELECT @WaitForSeconds = CONVERT(varchar, DATEADD(s, @RunIntervalSeconds , 0), 114)
SELECT @FileName = @LogFile + FORMAT ( GETDATE(), '-MM-dd-yyyy_m', 'en-US' ) + '.txt'

--Create the File Handler and Open the File
EXECUTE sp_OACreate 'Scripting.FileSystemObject', @OACreate OUT
EXECUTE sp_OAMethod @OACreate, 'OpenTextFile', @OAFile OUT, @FileName, 2, True, -2

--Write the Header
EXECUTE sp_OAMethod @OAFile, 'WriteLine', NULL,'Transactions/sec, Active Transactions, SQL Cache Memory (KB), Lock Requests/sec, Lock Timeouts/sec, Lock Waits/sec, Number of Deadlocks/sec, Average Wait Time (ms), Average Latch Wait Time (ms)'
--Collect Initial Sample Values
SET ANSI_WARNINGS OFF
SELECT
  @LastTPS= max(case when counter_name = 'Transactions/sec' then cntr_value end),
  @LastLRS = max(case when counter_name = 'Lock Requests/sec' then cntr_value end),
  @LastLTS = max(case when counter_name = 'Lock Timeouts/sec' then cntr_value end),
  @LastLWS = max(case when counter_name = 'Lock Waits/sec' then cntr_value end),
  @LastNDS = max(case when counter_name = 'Number of Deadlocks/sec' then cntr_value end),
  @LastAWT = max(case when counter_name = 'Average Wait Time (ms)' then cntr_value end),
  @LastAWT_Base = max(case when counter_name = 'Average Wait Time base' then cntr_value end),
  @LastALWT = max(case when counter_name = 'Average Latch Wait Time (ms)' then cntr_value end),
  @LastALWT_Base = max(case when counter_name = 'Average Latch Wait Time base' then cntr_value end)
FROM sys.dm_os_performance_counters
WHERE counter_name IN (
'Transactions/sec',
'Lock Requests/sec',
'Lock Timeouts/sec',
'Lock Waits/sec',
'Number of Deadlocks/sec',
'Average Wait Time (ms)',
'Average Wait Time base',
'Average Latch Wait Time (ms)',
'Average Latch Wait Time base') AND instance_name IN( '_Total' ,'')
SET ANSI_WARNINGS ON
WHILE @LoopCounter <= @Loops
BEGIN
WAITFOR DELAY @WaitForSeconds
SET ANSI_WARNINGS OFF
SELECT
  @TPS= max(case when counter_name = 'Transactions/sec' then cntr_value end)   ,
  @Active = max(case when counter_name = 'Active Transactions' then cntr_value end)   ,
  @SCM = max(case when counter_name = 'SQL Cache Memory (KB)' then cntr_value end)   ,
  @LRS = max(case when counter_name = 'Lock Requests/sec' then cntr_value end)   ,
  @LTS = max(case when counter_name = 'Lock Timeouts/sec' then cntr_value end)   ,
  @LWS = max(case when counter_name = 'Lock Waits/sec' then cntr_value end)   ,
  @NDS = max(case when counter_name = 'Number of Deadlocks/sec' then cntr_value end)   ,
  @AWT = max(case when counter_name = 'Average Wait Time (ms)' then cntr_value end)   ,
  @AWT_Base = max(case when counter_name = 'Average Wait Time base' then cntr_value end)   ,
  @ALWT = max(case when counter_name = 'Average Latch Wait Time (ms)' then cntr_value end)   ,
  @ALWT_Base = max(case when counter_name = 'Average Latch Wait Time base' then cntr_value end)
FROM sys.dm_os_performance_counters
WHERE counter_name IN (
'Transactions/sec',
'Active Transactions',
'SQL Cache Memory (KB)',
'Lock Requests/sec',
'Lock Timeouts/sec',
'Lock Waits/sec',
'Number of Deadlocks/sec',
'Average Wait Time (ms)',
'Average Wait Time base',
'Average Latch Wait Time (ms)',
'Average Latch Wait Time base') AND instance_name IN( '_Total' ,'')
SET ANSI_WARNINGS ON

SELECT  @AWT_DIV = case when (@AWT_Base - @LastAWT_Base) > 0 then (@AWT_Base - @LastAWT_Base) else 1 end ,
    @ALWT_DIV = case when (@ALWT_Base - @LastALWT_Base) > 0 then (@ALWT_Base - @LastALWT_Base) else 1 end

SELECT @RowText = '' + convert(varchar, (@TPS - @LastTPS)/@RunIntervalSeconds) + ', ' +
          convert(varchar, @Active) + ', ' +
          convert(varchar, @SCM) + ', ' +
          convert(varchar, (@LRS - @LastLRS)/@RunIntervalSeconds) + ', ' +
          convert(varchar, (@LTS - @LastLTS)/@RunIntervalSeconds) + ', ' +
          convert(varchar, (@LWS - @LastLWS)/@RunIntervalSeconds) + ', ' +
          convert(varchar, (@NDS - @LastNDS)/@RunIntervalSeconds) + ', ' +
          convert(varchar, (@AWT - @LastAWT)/@AWT_DIV) + ', ' +
          convert(varchar, (@ALWT - @LastALWT)/@ALWT_DIV)

SELECT  @LastTPS = @TPS,
    @LastLRS = @LRS,
    @LastLTS = @LTS,
    @LastLWS = @LWS,
    @LastNDS = @NDS,
    @LastAWT = @AWT,
    @LastAWT_Base = @AWT_Base,
    @LastALWT = @ALWT,
    @LastALWT_Base = @ALWT_Base

EXECUTE sp_OAMethod @OAFile, 'WriteLine', Null, @RowText

SET @LoopCounter = @LoopCounter + 1

END

--CLEAN UP
EXECUTE sp_OADestroy @OAFile
EXECUTE sp_OADestroy @OACreate
print 'Completed Logging Performance Metrics to file: ' + @FileName

END

GO

Executando o teste de carga TPROC-C

No SQL Server Management Studio, execute o procedimento de coleta usando o seguinte script:

Use master
Go
exec dbo.sp_write_performance_counters

Na instância do Compute Engine em que você instalou o HammerDB, inicie o teste no aplicativo HammerDB:

1. No painel Benchmark , em Virtual Users, clique duas vezes em Create para criar os usuários virtuais, o que ativará a guia Virtual User Output .
2. Clique duas vezes em Executar logo abaixo da opção Criar para iniciar o teste.
3. Quando o teste for concluído, você verá o cálculo de Transações por Minuto (TPM) na guia Saída do Usuário Virtual .
4. Você pode encontrar os resultados do seu procedimento de coleta no diretório c:\Windows\temp .
5. Salve todos esses valores em uma Planilha Google e use-os para comparar vários testes.