Teste de carga do SQL Server usando HammerDB

Neste tutorial, há informações sobre como usar o Hammer DB para fazer testes de carga em uma instância do SQL Server do Google 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:

  • Google Compute Engine
  • Windows Server

Use a calculadora de preços para gerar uma estimativa de custo com base no uso previsto. 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 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 GCP.

    Acessar a página Gerenciar recursos

  3. Verifique se o faturamento foi ativado para o projeto.

    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:

    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.

    Configurar modelo de recuperação como Simple

  11. Clique em OK para criar o banco de dados TPCC, o que pode demorar alguns minutos.

  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 o Tipo de máquina para, no mínimo, metade do número de CPUs da 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.

Instalar o software

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

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, uma 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.

    Definir as opções de benchmark do TPC-C

  4. No painel Benchmark ao lado de SQL Server, clique em + 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.

    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 fechar a caixa de diálogo.
  7. Clique duas vezes em Load na seção Driver Script do painel Benchmark para ativar o script do driver.

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 10 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 tempo 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

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, 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. Consulte os resultados do procedimento de coleta 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.

Como fazer a limpeza

Depois de concluir o tutorial do SQL Server, é possível limpar os recursos criados no Google Cloud Platform para que eles não ocupem cotas e sejam cobrados no futuro. Nas seções a seguir, aprenda a excluir e desativar esses recursos.

Como excluir o projeto

A maneira mais fácil de evitar o faturamento é excluir o projeto criado para o tutorial.

Para excluir o projeto:

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

    Acessar a página Projetos

  2. Na lista de projetos, selecione o que você quer excluir e clique em Excluir projeto. Após marcar a caixa de seleção ao lado do nome do projeto, clique em Excluir projeto
  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 da VM".

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

  2. Clique na caixa de seleção ao lado da da instância que deseja excluir.
  3. Clique no botão Excluir na parte superior da página para excluir a instância.

Próximas etapas

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

Enviar comentários sobre…