Tests de charge SQL Server avec HammerDB

Ce tutoriel vous explique comment utiliser HammerDB pour réaliser des tests de charge sur une instance SQL Server de Google Compute Engine. Pour apprendre à installer une instance SQL Server, consultez les tutoriels suivants :

Il existe un certain nombre d'outils de test de charge. Certains sont libres ou Open Source, tandis que d'autres nécessitent des licences. HammerDB est un outil Open Source qui fonctionne généralement bien pour prouver les performances de votre base de données SQL Server. Ce tutoriel décrit les grandes lignes de l'utilisation de HammerDB, mais d'autres outils sont disponibles : choisissez ceux qui correspondent le mieux à vos charges de travail spécifiques.

Objectifs

  • Configurer SQL Server pour les tests de charge.
  • Installer et exécuter HammerDB.
  • Recueillir des statistiques d'exécution.
  • Exécuter le test de charge TPC-C.

Coûts

Outre les instances SQL Server existantes exécutées sur Compute Engine, ce tutoriel utilise des composants facturables de Google Cloud Platform (GCP), par exemple :

  • Google Compute Engine
  • Windows Server

Le simulateur de coût peut générer une estimation des coûts en fonction de votre utilisation prévue. Le lien fourni présente le coût estimé pour les produits utilisés dans ce tutoriel, qui peut représenter en moyenne 16 dollars US par jour. Les nouveaux utilisateurs de Cloud Platform peuvent bénéficier d'un essai gratuit.

Avant de commencer

  1. Connectez-vous à votre compte Google.

    Si vous n'en possédez pas déjà un, vous devez en créer un.

  2. Sélectionnez ou créez un projet Google Cloud Platform.

    Accéder à la page "Gérer les ressources"

  3. Assurez-vous que la facturation est activée pour votre projet Google Cloud Platform.

    Découvrir comment activer la facturation

  4. Si vous n'utilisez pas Windows sur votre ordinateur local, installez un client RDP tiers tel que l'extension Chrome RDP de FusionLabs.

Configurer l'instance SQL Server pour les tests de charge

Avant de commencer, vérifiez que vos règles de pare-feu Windows sont configurées pour autoriser le trafic depuis l'adresse IP de la nouvelle instance Windows que vous avez créée. Créez ensuite une nouvelle base de données pour le test de charge TPCC et configurez un compte utilisateur en procédant comme suit :

  1. Cliquez avec le bouton droit sur le dossier Databases (bases de données) dans SQL Server Management Studio, puis choisissez New Database (nouvelle base de données).
  2. Nommez la nouvelle base de données "TPCC".
  3. Définissez la taille initiale du fichier de données à 190 000 Mo et celle du fichier journal à 65 000 Mo.
  4. Augmentez les limites Autogrowth (croissance automatique) en cliquant sur le bouton représentant des points de suspension, comme illustré à la capture d'écran suivante :

    Définir des limites de croissance automatique

  5. Autorisez le fichier de données à croître par paliers de 64 Mo jusqu'à une taille illimitée.

  6. Désactivez la croissance automatique pour le fichier journal.

  7. Cliquez sur OK.

    Modifier la boîte de dialogue de croissance automatique

  8. Dans la boîte de dialogue New Database (nouvelle base de données), dans le volet gauche, choisissez la page Options.

  9. Définissez Compatibility level (niveau de compatibilité) sur SQL Server 2012 (110).

  10. Définissez Recovery model (modèle de récupération) sur Simple, pour éviter que le chargement ne sature les journaux de transactions.

    Définir le modèle de récupération sur la valeur Simple

  11. Cliquez sur OK pour créer la base de données TPCC, ce qui peut prendre quelques minutes.

  12. Seule l'authentification Windows est activée dans l'image SQL Server préconfigurée. Vous devez donc activer l'authentification en mode mixte dans SSMS en suivant ce guide.

  13. Suivez ces étapes pour créer un nouveau compte utilisateur SQL Server possédant les autorisations DBOwner sur votre serveur de base de données. Nommez le compte "loaduser" et attribuez-lui un mot de passe sécurisé.

  14. Notez l'adresse IP interne de votre serveur SQL Server à l'aide du commandlet Get-NetIPAddress, car il est essentiel d'utiliser l'adresse IP interne pour des questions de performances et de sécurité.

Installer HammerDB

Vous pouvez exécuter HammerDB directement sur votre instance SQL Server. Toutefois, pour une précision accrue, créez une nouvelle instance Windows et testez l'instance SQL Server à distance.

Créer une instance

Pour créer une instance de Compute Engine, procédez comme suit :

  1. Dans la console Google Cloud Platform, accédez à la page Instances de VM.

    ACCÉDER À LA PAGE "INSTANCES DE VM"

  2. Dans le champ Nom, indiquez hammerdb-instance.

  3. Définissez le Type de machine à au moins la moitié du nombre de processeurs de votre instance de base de données.

  4. Dans la section Disque de démarrage, cliquez sur Modifier pour commencer à configurer le disque de démarrage.

  5. Dans l'onglet Images d'OS, choisissez Windows Server 2012 R2.

  6. Dans la section Type de disque de démarrage, sélectionnez Disque persistant standard.

  7. Cliquez sur Sélectionner.

  8. Cliquez sur Créer.

Installer le logiciel

Lorsque votre nouvelle instance Windows Server est prête, accédez-y et installez les logiciels suivants :

Exécuter HammerDB

Après avoir installé HammerDB, exécutez le fichier hammerdb.bat. HammberDB n'apparaît pas dans la liste des applications du menu Démarrer. Pour l'exécuter, utilisez la commande suivante :

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

Créer la connexion et le schéma

Une fois que l'application s'exécute, la première étape consiste à configurer la connexion pour générer le schéma.

  1. Dans le panneau Benchmark, double-cliquez sur SQL Server.
  2. Choisissez TPC-C, acronyme qui signifie : Transaction Processing Performance Council - Benchmark C. Sur le site TPC.org :
    TPC-C utilise une combinaison de cinq transactions simultanées de différents types et complexités, exécutées en ligne ou mises en file d'attente pour une exécution différée. La base de données comprend neuf types de tableaux représentant un large éventail de tailles d'enregistrements et de populations. TPC-C est mesuré en transactions par minute (tpmC).
  3. Cliquez sur OK.

    Définir les options de test TPC-C

  4. Dans le panneau Benchmark, à côté de SQL Server, cliquez sur le symbole + pour développer les options.

  5. Sous TPC-C, cliquez sur Schema Build (génération de schéma), puis double-cliquez sur Options.

  6. Remplissez le formulaire pour obtenir un résultat semblable à la figure ci-dessous, mais utilisant votre adresse IP, votre nom d'utilisateur et votre mot de passe.

    Définir les options de génération TPC-C

  7. Pour l'option Schema (schéma), choisissez Updated (mis à jour), qui crée un meilleur schéma TPC-C comportant une structure plus adaptée et de meilleurs index.

  8. Dans cet exemple, la valeur Number of Warehouses (nombre d'entrepôts, qui correspond à l'échelle) est définie à 2 000, mais vous pouvez choisir une valeur inférieure car la création de 2 000 entrepôts prendra plusieurs heures. Certaines recommandations suggèrent 10 à 100 entrepôts par processeur. Pour les besoins de ce tutoriel, définissez cette valeur à 10 fois le nombre de cœurs : pour une instance à 16 cœurs, cela correspond à 160.

  9. Pour l'option Virtual Users to Build Schema (utilisateurs virtuels pour la génération de schéma), choisissez un nombre compris entre 1 et 2 fois le nombre de processeurs virtuels clients. Vous pouvez cliquer sur la barre grise à côté du curseur pour augmenter ce nombre.

  10. Cliquez sur OK.

  11. Pour générer le schéma et charger les tables, double-cliquez sur l'option Build (générer) sous la section Schema Build (génération de schéma). Une fois la génération terminée, cliquez sur l'icône en forme de gyrophare rouge, située en haut et au milieu de l'écran, pour supprimer l'utilisateur virtuel et passer à l'étape suivante.

Si vous avez créé votre base de données avec le modèle de récupération Simple, il peut être judicieux à ce stade de remplacer ce modèle par Full pour obtenir un test plus proche d'un scénario de production. Cela ne prendra effet qu'après une sauvegarde complète ou différentielle, qui déclenchera le démarrage de la nouvelle chaîne de journaux.

Créer le script de pilote

HammerDB utilise un script de pilote (driver script) pour orchestrer le flux d'instructions SQL vers la base de données afin de générer la charge requise.

  1. Dans le panneau Benchmark, développez la section Driver Script (script de pilote) et double-cliquez sur Options.
  2. Vérifiez que les paramètres correspondent à ceux que vous avez utilisés dans la boîte de dialogue Schema Build (génération de schéma).
  3. Choisissez l'option Timed Test Driver Script (script de pilote pour test chronométré).
  4. L'option Checkpoint when complete (point de contrôle en fin de test) oblige la base de données à tout écrire sur le disque à la fin du test. Ne cochez donc cette option que si vous prévoyez d'exécuter plusieurs tests à la suite.
  5. Pour garantir un test approfondi, définissez le paramètre Minutes of Rampup Time (durée de la montée en charge) sur 5 et Minutes for Test Duration (durée du test en minutes) sur 20.
  6. Cliquez sur OK pour quitter la boîte de dialogue.
  7. Pour activer le script de pilote, double-cliquez sur Load (charger) dans la section Driver script (script de pilote) du panneau Benchmark.

Définir les options de pilote TPC-C)

Créer des utilisateurs virtuels

Pour créer une charge réaliste, il est généralement nécessaire de faire exécuter les scripts par plusieurs utilisateurs différents. Pour le test, créez donc plusieurs utilisateurs virtuels.

  1. Développez la section Virtual Users (utilisateurs virtuels) et double-cliquez sur Options.
  2. Si vous avez défini le nombre d'entrepôts (échelle) à 160, définissez le nombre d'utilisateurs virtuels Virtual Users (utilisateurs virtuels) à 16, car les instructions TPC-C recommandent un ratio de 10 pour empêcher le verrouillage des lignes. Cochez la case Show output (afficher la sortie) pour activer l'affichage des messages d'erreur dans la console.
  3. Cliquez sur OK.

Recueillir les statistiques d'exécution

La collecte de statistiques d'exécution détaillées n'est pas particulièrement simple dans HammerDB et SQL Server. Bien que les statistiques soient disponibles au sein de SQL Server, elles doivent être capturées et calculées régulièrement. Si vous n'avez pas encore de procédure ou d'outil permettant de capturer ces données, vous pouvez utiliser la procédure ci-dessous pour recueillir des statistiques utiles lors de vos tests. Les résultats seront enregistrés dans un fichier CSV dans le répertoire temp de Windows. Vous pouvez copier les données sur une feuille de calcul Google Sheet à l'aide de l'option Collage spécial > Collage CSV .

Pour utiliser cette procédure, vous devez d'abord activer temporairement l'option OLE Automation Procedures (procédures d'automatisation OLE) pour écrire le fichier sur le disque. N'oubliez pas de la désactiver après le test :

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

Voici le code permettant de créer la procédure sp_write_performance_counters dans SQL Server Management Studio. Avant de démarrer le test de charge, vous allez exécuter cette procédure dans 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

Réaliser le test de charge TPC-C

Dans SQL Server Management Studio, exécutez la procédure de collecte au moyen du script suivant :

Use master
Go
exec dbo.sp_write_performance_counters

Sur l'instance Compute Engine dans laquelle vous avez installé HammerDB, lancez le test dans l'application HammerDB :

  1. Dans le panneau Benchmark, sous Virtual Users (utilisateurs virtuels), double-cliquez sur Create (créer) pour générer les utilisateurs virtuels. Cela active l'onglet Virtual User Output (sortie de l'utilisateur virtuel).
  2. Pour lancer le test, double-cliquez sur Run (exécuter) juste en dessous de l'option Create (créer).
  3. Une fois le test terminé, le calcul des transactions par minute (TPM) apparaît dans l'onglet Virtual User Output (sortie de l'utilisateur virtuel).
  4. Vous pouvez retrouver les résultats de votre procédure de collecte de statistiques dans le répertoire c:\Windows\temp.
  5. Enregistrez toutes ces valeurs dans une feuille de calcul Google Sheet et utilisez-les pour comparer plusieurs cycles de test.

Nettoyer

Une fois que vous avez terminé ce tutoriel de test de charge SQL Server, vous pouvez nettoyer les ressources que vous avez créées sur Google Cloud Platform afin d'éviter qu'elles ne vous soient facturées à l'avenir. Dans les sections suivantes, nous allons voir comment supprimer ou désactiver ces ressources.

Supprimer le projet

Le moyen le plus simple d'empêcher la facturation est de supprimer le projet que vous avez créé dans le cadre de ce tutoriel.

Pour supprimer le projet, procédez comme suit :

  1. Dans la console GCP, accédez à la page Projets.

    Accéder à la page Projets

  2. Dans la liste des projets, sélectionnez le projet que vous souhaitez supprimer, puis cliquez sur Supprimer delete.
  3. Dans la boîte de dialogue, saisissez l'ID du projet, puis cliquez sur Arrêter pour supprimer le projet.

Supprimer des instances

Pour supprimer une instance Compute Engine, procédez comme suit :

  1. Dans la console GCP, accédez à la page Instances de VM.

    Accéder à la page Instances de VM

  2. Cochez la case à côté de l'instance que vous souhaitez supprimer.
  3. Cliquez sur le bouton Supprimer delete situé en haut de la page pour supprimer l'instance.

Étapes suivantes

Cette page vous a-t-elle été utile ? Évaluez-la :

Envoyer des commentaires concernant…