Teste de carga do SQL Server usando HammerDB

Neste tutorial, mostramos como usar o HammerDB para realizar testes de carga em uma instância do SQL Server do Compute Engine. Confira como instalar uma instância do SQL Server com os seguintes tutoriais:

Há várias ferramentas para teste de carga. Algumas são gratuitas e de código aberto, para outras é necessário ter uma licença. O HammerDB é uma ferramenta de código aberto que geralmente funciona bem para testar o desempenho do banco de dados SQL Server. Neste tutorial, são apresentadas as etapas básicas para usar o HammerDB, mas há outras ferramentas disponíveis. Selecione as ferramentas mais adequadas às suas cargas de trabalho específicas.

Objetivos

  • Configurar o SQL Server para teste de carga.
  • Instalar e executar o HammerDB.
  • Coletar estatísticas de tempo de execução.
  • Executar o teste de carga TPC-C.

Custos

Além das instâncias do SQL Server em execução no Compute Engine, há componentes do Google Cloud Platform (GCP) passíveis de cobrança, inclusive estes:

  • Compute Engine
  • Windows Server

A Calculadora de preços pode gerar uma estimativa de custos com base no uso projetado. Confira no link fornecido a estimativa de custos dos produtos usados nesse tutorial, que custam em média US$ 16 por dia. Novos usuários do Google Cloud Platform podem estar qualificados para uma avaliação gratuita.

Antes de começar

  1. Faça login na sua Conta do Google.

    Se você ainda não tiver uma, inscreva-se.

  2. Selecione ou crie um projeto do Google Cloud Platform.

    Acessar a página Gerenciar recursos

  3. Verifique se o faturamento foi ativado no projeto do Google Cloud Platform.

    Saiba como ativar o faturamento

  4. Se você não estiver usando o Windows na máquina local, instale um cliente RDP de terceiros como o Chrome RDP da FusionLabs.

Como configurar o SQL Server para teste de carga

Antes de começar, verifique novamente 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. Depois crie um novo banco de dados para o teste de carga TPCC e configure uma conta de usuário seguindo estas etapas:

  1. Clique com o botão direito do mouse na pasta Bancos de dados no SQL Server Management Studio e selecione Novo banco de dados.
  2. Defina o nome do novo banco de dados como "TPCC".
  3. Defina o tamanho inicial do arquivo de dados em 190.000 MB e do arquivo de registros em 65.000 MB.
  4. Clique nos botões de reticências para aumentar os limites do Aumento automático, como mostrado na captura de tela a seguir:

    Como configurar limites de aumento automático

  5. Configure o arquivo de dados para crescer em incrementos de 64 MB até um tamanho ilimitado.

  6. Na configuração do arquivo de registros, desative o aumento automático.

  7. Clique em OK.

    Caixa de diálogo Alterar aumento automático

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

  9. Defina o Nível de compatibilidade como SQL Server 2012 (110).

  10. Defina o Modelo de recuperação como Simples, para que a carga não preencha os registros de transação.

    Como configurar modelo de recuperação como Simple

  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 contém apenas a autenticação do Windows. Portanto, será necessário ativar 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 com a permissão DBOwner. Defina o nome da conta como "Loaduser" e crie uma senha segura.

  14. Use o commandlet Get-NetIPAddress para anotar o endereço IP interno do SQL Server, porque o uso do IP interno é importante para o desempenho e a segurança.

Como instalar o HammerDB

Instale o HammerDB diretamente na instância do SQL Server. No entanto, para um teste mais preciso, crie uma nova instância do Windows e faça um teste remoto da instância do SQL Server.

Como criar uma instância

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

  1. No Console do Google Cloud Platform, acesse a página Instâncias de VMs.

    ACESSAR A PÁGINA "INSTÂNCIAS DE VMs"

  2. Defina o Nome como hammerdb-instance.

  3. Defina Configuração da máquina como 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 para configurar o disco de inicialização.

  5. Na guia Imagens do SO, selecione Windows Server 2012 R2.

  6. Na seção Tipo de disco de inicialização, selecione Disco permanente padrão.

  7. Clique em Selecionar.

  8. Clique em Criar.

Como instalar o software

Quando a nova instância do Windows Server estiver pronta, acesse-a por meio do RDP e instale os seguintes softwares:

Como executar o HammerDB

Depois de instalar o HammerDB, execute o arquivo hammerdb.bat. Ele não aparece na lista de aplicativos do menu "Iniciar". Use o seguinte comando para executá-lo:

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

Como criar a conexão e o esquema

Com o aplicativo em execução, a primeira etapa é configurar a conexão para criar o esquema.

  1. Clique duas vezes em SQL Server no painel Benchmark.
  2. Selecione TPC-C, sigla que vem do inglês "Transaction Processing Performance Council - Benchmark C". De acordo com o site TPC.org:
    o TPC-C envolve uma combinação de cinco transações simultâneas de tipos e complexidades diferentes, executadas on-line ou colocadas em fila para execução adiada. O banco de dados é composto por nove tipos de tabelas com uma ampla gama de tamanhos de registro e população. O TPC-C é medido em transações por minuto (tpmC, na sigla em inglês).
  3. Clique em OK.

    Como definir as opções de benchmark do TPC-C

  4. No painel Benchmark, ao lado de SQL Server, clique no sinal de adição (+) para expandir as opções.

  5. Abaixo de TPC-C, clique em Schema Build e clique duas vezes em Options.

  6. Preencha o formulário como na figura abaixo, usando seu endereço IP, nome de usuário e senha.

    Como definir as opções de criação do TPC-C

  7. Para a opção Schema selecione Updated. Isso cria um esquema de TPC-C melhor, com uma estrutura mais adequada e índices mais eficientes.

  8. Nesse caso, o Number of Warehouses (a escala) está definido como 2.000, mas não é necessário configurar um valor tão alto, porque criar 2.000 depósitos demoraria várias horas. Algumas diretrizes sugerem de 10 a 100 depósitos por CPU. Para este tutorial, configure o valor como 10 vezes o número de núcleos, por exemplo, 160 para uma instância de 16 núcleos.

  9. Em Virtual Users to Build Schema, selecione um número entre uma e duas vezes o número de vCPUs clientes. Clique na barra cinza ao lado do controle deslizante para aumentar o número.

  10. Clique em OK.

  11. Clique duas vezes na opção Build embaixo da seção Schema Build para criar o esquema e carregar as tabelas. Assim que o processo terminar, clique no ícone lâmpada vermelha na parte superior central da tela para destruir o usuário virtual e passar para a etapa seguinte.

Se você criou seu banco de dados com o modelo de recuperação Simple, retorne para Full neste ponto para um teste mais preciso de um cenário de produção. Essa ação somente terá efeito depois de ser feito um backup completo ou diferencial para acionar o início da nova cadeia de registros.

Como criar o script do driver

O script do driver é utilizado no HammerDB para organizar o fluxo de instruções SQL ao 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 às utilizadas na caixa de diálogo Schema Build.
  3. Selecione Timed Test Driver Script.
  4. Com a opção Checkpoint when complete, tudo é gravado no disco ao final do teste do banco de dados, portanto, marque essa opção somente se planeja executar diversos testes de uma só vez.
  5. Para garantir um teste minucioso, defina Minutes of Rampup Time como 5 e Minutes for Test Duration como 20.
  6. Clique em OK para sair do diálogo.
  7. Clique duas vezes em Load na seção Driver Script do painel Benchmark para ativar o script do driver.

Como definir as opções de driver do TPC-C)

Como criar usuários virtuais

Criar uma carga realista geralmente 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 Virtual Users e clique duas vezes em Options.
  2. Se você definir a contagem de depósitos (escala) como 160, defina Virtual Users como 16, já que as diretrizes do TPC-C recomendam uma proporção de dez vezes para evitar o bloqueio da linha. Marque a caixa de seleção Show Output para ativar mensagens de erro no console.
  3. Clique em OK.

Como coletar estatísticas de ambiente de execução

Não é fácil coletar estatísticas detalhadas de tempo de execução no HammerDB e no SQL Server. Ainda que estejam disponíveis dentro do SQL Server, elas precisam ser capturadas e calculadas regularmente. Se você ainda não tem um procedimento ou uma ferramenta que ajude na captura desses dados, use o procedimento a seguir para capturar algumas métricas úteis durante os testes. Os resultados são gravados em um arquivo CSV no diretório temp do Windows. Copie os dados para uma Planilha Google com a opção Colar especial > Colar CSV.

Antes de fazer isso, ative temporariamente os Procedimentos de automação OLE para gravar o arquivo no disco. Lembre-se de desativar essa opção após o teste.

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

Veja o código para criar o procedimento sp_write_performance_counters no SQL Server Management Studio. Antes de iniciar o teste de carga, execute 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

Como executar o teste de carga TPC-C

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

Use master
Go
exec dbo.sp_write_performance_counters

Inicie o teste no aplicativo HammerDB na instância do Compute Engine em que você instalou o HammerDB:

  1. No painel Benchmark, em Virtual Users, clique duas vezes em Create para criar os usuários virtuais, o que ativa a guia Virtual User Output.
  2. Clique duas vezes em Run abaixo da opção Create para iniciar o teste.
  3. Depois de concluir o teste, veja o cálculo de transações por minuto (TPM) na guia Virtual User Output.
  4. Os resultados do procedimento de coleta podem ser encontrados no diretório c:\Windows\temp.
  5. Salve todos os valores em um arquivo do Planilhas Google para comparar as várias execuções de teste.

Limpeza

Depois de concluir o tutorial de teste de carga, será possível limpar os recursos criados no GCP para que eles não ocupem cotas e você não seja cobrado por eles no futuro. Veja como excluir e desativar esses recursos nas seções a seguir.

Como 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, faça o seguinte:

  1. No Console do GCP, acesse a página Projetos.

    Acessar a página Projetos

  2. Na lista de projetos, selecione o projeto que você quer excluir e clique em Excluir delete.
  3. Na caixa de diálogo, digite o código do projeto e clique em Encerrar para excluí-lo.

Como excluir instâncias

Para excluir uma instância do Compute Engine:

  1. No Console do GCP, acesse a página Instâncias de VM.

    Acessar a página "Instâncias de VMs"

  2. Clique na caixa de seleção ao lado da a instância que você quer excluir.
  3. Para excluir a instância, clique em Excluir excluir no topo da página.

A seguir

Esta página foi útil? Conte sua opinião sobre:

Enviar comentários sobre…