Ce tutoriel explique comment utiliser HammerDB pour effectuer des tests de charge sur une instance SQL Server de 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 gratuits et Open Source, tandis que d'autres nécessitent des licences. HammerDB est un outil Open Source qui fonctionne généralement bien pour démontrer 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, par exemple :
- 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.
Avant de commencer
- Connectez-vous à votre compte Google Cloud. Si vous débutez sur Google Cloud, créez un compte pour évaluer les performances de nos produits en conditions réelles. Les nouveaux clients bénéficient également de 300 $ de crédits gratuits pour exécuter, tester et déployer des charges de travail.
-
Dans Google Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Google Cloud.
-
Vérifiez que la facturation est activée pour votre projet Google Cloud.
-
Dans Google Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Google Cloud.
-
Vérifiez que la facturation est activée pour votre projet Google Cloud.
- Si vous n'utilisez pas Windows sur votre ordinateur local, installez un client RDP (Remote Desktop Protocol) tiers. Pour plus d'informations, voir les clients Bureau à distance de Microsoft.
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 :
- 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).
- Nommez la nouvelle base de données "TPCC".
- Définissez la taille initiale du fichier de données à 190 000 Mo et celle du fichier journal à 65 000 Mo.
Augmentez les limites Autogrowth (Croissance automatique) en cliquant sur le bouton représentant des points de suspension, comme illustré à la capture d'écran suivante :
Autorisez le fichier de données à croître par paliers de 64 Mo jusqu'à une taille illimitée.
Désactivez la croissance automatique pour le fichier journal.
Cliquez sur OK.
Dans la boîte de dialogue New Database (nouvelle base de données), dans le volet gauche, choisissez la page Options.
Définissez Compatibility level (niveau de compatibilité) sur SQL Server 2012 (110).
Définissez Recovery model (modèle de récupération) sur Simple, pour éviter que le chargement ne sature les journaux de transactions.
Cliquez sur OK pour créer la base de données TPCC. Cette opération peut prendre quelques minutes.
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.
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é.
Prenez note de l'adresse IP interne de SQL Server à l'aide du commandlet
Get-NetIPAddress, car cette adresse est importante pour la sécurité et les performances.
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 :
Accédez à la page Créer une instance dans Google Cloud Console.
Dans le champ Nom, saisissez
hammerdb-instance.Dans la section Configuration de la machine, sélectionnez le type de machine, avec au moins la moitié du nombre de processeurs de votre instance de base de données.
Dans la section Disque de démarrage, cliquez sur Modifier, puis procédez comme suit :
- Dans l'onglet Images publiques, choisissez un système d'exploitation Windows Server.
- Dans la liste Version, cliquez sur Windows Server 2012 R2 ou Windows Server 2012 R2 Core.
- Dans la liste Type de disque de démarrage, sélectionnez Disque persistant standard.
- Cliquez sur Sélectionner pour confirmer vos options de disque de démarrage.
Pour créer et démarrer la VM, cliquez sur Créer.
Installer le logiciel
Lorsqu'elle est prête, utilisez un client RDP pour vous connecter à votre nouvelle instance Windows Server et installer 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.
- Dans le panneau Benchmark, double-cliquez sur SQL Server.
- Choisissez TPC-C, acronyme qui signifie : Transaction Processing Performance Council - Benchmark C.
Depuis le site TPC.org :
TPC-C utilise une combinaison de cinq transactions simultanées de différents types et niveaux de complexité, 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).
Cliquez sur OK.
Dans le panneau Benchmark, à côté de SQL Server, cliquez sur le signe plus (+) pour développer les options.
Sous TPC-C, cliquez sur Schema Build (Génération de schéma), puis double-cliquez sur Options.
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.
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.
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.
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.
Cliquez sur OK.
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.
- Dans le panneau Benchmark, développez la section Driver Script (script de pilote) et double-cliquez sur Options.
- 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).
- Choisissez l'option Timed Test Driver Script (Script de pilote pour test chronométré).
- 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.
- 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.
- Cliquez sur OK pour quitter la boîte de dialogue.
- Pour activer le script de pilote, double-cliquez sur Load (Charger) dans la section Driver script (Script de pilote) du panneau Benchmark.
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. Par conséquent, créez plusieurs utilisateurs virtuels pour le test.
- Développez la section Virtual Users (Utilisateurs virtuels) et double-cliquez sur Options.
- 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.
- 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 Sheets à 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
Le code permettant de créer la procédure sp_write_performance_counters dans SQL Server Management Studio est présenté ci-dessous. 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 :
- 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).
- Pour lancer le test, double-cliquez sur Run (Exécuter) juste en dessous de l'option Create (Créer).
- 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).
- Vous pouvez retrouver les résultats de votre procédure de collecte dans le répertoire
c:\Windows\temp. - Enregistrez toutes ces valeurs dans une feuille de calcul Google Sheet et utilisez-les pour comparer plusieurs cycles de test.
Nettoyer
Une fois le tutoriel terminé, vous pouvez procéder au nettoyage des ressources que vous avez créées afin qu'elles ne soient plus comptabilisées dans votre quota et qu'elles ne vous soient plus facturées. 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éé pour ce tutoriel.
Pour supprimer le projet :
- Dans la console Google Cloud, accédez à la page Gérer les ressources.
- Dans la liste des projets, sélectionnez le projet que vous souhaitez supprimer, puis cliquez sur Supprimer.
- 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 :
- Dans la console Google Cloud, accédez à la page Instances de VM.
- Cochez la case correspondant à instance que vous souhaitez supprimer.
- Pour supprimer l'instance, cliquez sur Autres actions , cliquez sur Supprimer, puis suivez les instructions.
Étape suivante
- Consultez le Guide des bonnes pratiques SQL Server.
- Découvrez des architectures de référence, des schémas et des bonnes pratiques concernant Google Cloud. Consultez notre Centre d'architecture cloud.