Utiliser l’outil Sqldumper.exe pour générer un fichier de vidage dans SQL Server

Article
11/20/2024

Cet article fournit des instructions générales pour l’outil Sqldumper.exe inclus dans SQL Server. Cet outil est utilisé pour générer différents types de fichiers de vidage.

Version de produit d’origine : SQL Server 2019, SQL Server 2017, SQL Server 2016, SQL Server 2014, SQL Server 2012, SQL Server 2008, SQL Server 2005
Numéro de base de connaissances d’origine : 917825

Résumé

L’outil Sqldumper.exe est inclus dans Microsoft SQL Server. Il génère des fichiers de vidage de mémoire de SQL Server et des processus connexes pour le débogage. Cet article explique comment utiliser Sqldumper.exe pour générer un fichier de vidage pour les tâches de création de rapports d’erreurs Watson ou de débogage.

L’article décrit également deux autres méthodes pour générer des fichiers de vidage :

Le script PowerShell attaché automatise SQLDumper.exe options de ligne de commande.
La commande DBCC STACKDUMP Transact-SQL (T-SQL) peut être utilisée pour générer un fichier de vidage dans SQL Server.

Comment exécuter Sqldumper.exe manuellement

Exécutez l’outil Sqldumper.exe dans le contexte du dossier où SQL Server a initialement installé l’outil.

Par défaut, le chemin d’installation de Sqldumper.exe est <SQLServerInstall Drive> :\Program Files\Microsoft SQL Server\90\Shared\SQLDumper.exe. Notez que <le lecteur> SQLServerInstall est un espace réservé pour le lecteur sur lequel vous avez installé SQL Server.

Pour générer un fichier de vidage à l’aide de l’outil Sqldumper.exe, procédez comme suit :

Ouvrez <le lecteur> SQLServerInstall :\Program Files\Microsoft SQL Server\<number>\Shared folder.

Dans ce chemin d’accès au dossier, <le nombre> est un espace réservé pour l’une des versions suivantes :
- 150 pour SQL Server 2019
- 140 pour SQL Server 2017
- 130 pour SQL Server 2016
- 120 pour SQL Server 2014
- 110 pour SQL Server 2012
- 100 pour SQL Server 2008
- 90 pour SQL Server 2005
Assurez-vous que le fichier Dbghelp.dll se trouve dans ce dossier.
Sélectionnez Démarrer>l’exécution, tapez cmd, puis sélectionnez OK.
À l’invite de commandes, tapez la commande suivante et appuyez sur Entrée :
```
cd <SQLServerInstall Drive>:\Program Files\Microsoft SQL Server\<number>\Shared
```
Note

Dans ce chemin d’accès au dossier, <le nombre> est le même espace réservé que celui qui change avec la version de SQL Server, comme décrit précédemment.
Pour générer un type spécifique de fichier de vidage, tapez la commande correspondante à l’invite de commandes, puis appuyez sur Entrée :
- Fichier de vidage complet :
```
Sqldumper.exe <ProcessID> 0 0x01100
```
- Fichier de mini-vidage :
```
Sqldumper.exe <ProcessID> 0 0x0120
```
- Fichier de mini-vidage qui inclut indirectement la mémoire référencée (il s’agit de l’option recommandée et est également utilisé par SQL Server par défaut lorsqu’il génère automatiquement des fichiers de vidage de mémoire) :
```
Sqldumper.exe <ProcessID> 0 0x0128
```
- Fichier de vidage filtré :
```
Sqldumper.exe <ProcessID> 0 0x8100
```
Note

<ProcessID> est un espace réservé pour l’identificateur de processus de l’application Windows pour laquelle vous souhaitez générer un fichier de vidage.

Si Sqldumper.exe s’exécute correctement, l’outil génère un fichier de vidage dans le dossier dans lequel l’outil est installé.

Le fichier de vidage généré par Sqldumper.exe a un modèle de nom de fichier semblable à SQLDmpr<xxxx.mdmp>.

Dans ce modèle, <xxxx> est un nombre croissant qui est déterminé en fonction d’autres fichiers qui ont un nom de fichier similaire dans le même dossier. S’il existe des fichiers dans le dossier qui correspondent au modèle spécifié, envisagez de comparer leurs dates et heures de création pour trouver le fichier souhaité.

Comment obtenir un identificateur de processus d’application Microsoft Windows

Pour générer un fichier de vidage à l’aide de l’outil Sqldumper.exe, vous devez disposer de l’identificateur de processus de l’application Windows pour laquelle vous souhaitez générer un fichier de vidage. Voici comment obtenir l’identificateur de processus :

Appuyez sur Ctrl+Alt+Supprimer, puis sélectionnez Gestionnaire des tâches.
Dans la boîte de dialogue Gestionnaire des tâches Windows, sélectionnez l’onglet Processus .
Dans le menu Affichage , sélectionnez Sélectionner des colonnes.
Dans la boîte de dialogue Sélectionner des colonnes , cochez la case PID (Identificateur de processus), puis sélectionnez OK.
Notez l’identificateur de processus de l’application Windows pour laquelle vous souhaitez générer un fichier de vidage. Pour l’application SQL Server, notez l’identificateur de processus du processus Sqlservr.exe .
Fermez le Gestionnaire des tâches.

Vous pouvez également utiliser le fichier journal des erreurs SQL Server pour obtenir l’identificateur de processus de l’application SQL Server en cours d’exécution sur votre ordinateur. Une partie du fichier journal des erreurs SQL Server ressemble à l’exemple suivant :

2021-09-15 11:50:32.690 Server       Microsoft SQL Server 2019 (RTM-CU12) (KB5004524) - 15.0.4153.1 (X64)
    Jul 19 2021 15:37:34
    Copyright (C) 2019 Microsoft Corporation
    Enterprise Edition (64-bit) on Windows 10 Pro 10.0 <X64> (Build 19043: ) (Hypervisor)
2021-09-15 11:50:32.690 Server       UTC adjustment: -5:00
2021-09-15 11:50:32.690 Server       (c) Microsoft Corporation.
2021-09-15 11:50:32.690 Server       All rights reserved.
2021-09-15 11:50:32.690 Server       Server process ID is 7028.

Le nombre qui apparaît après Server process ID est l’identificateur de processus du processus Sqlservr.exe .

Chemin d’accès de sortie pour les fichiers de vidage de mémoire

SQLDumper.exe génère principalement des fichiers de vidage de mémoire pour le processus SQL Server lorsqu’un vidage de mémoire est nécessaire pour résoudre des problèmes spécifiques, tels que des exceptions, des assertions ou des planificateurs sans rendement. Dans ce cas, SQL Server appelle le SQLDumper.exe pour générer un fichier de vidage de mémoire de son processus. Par défaut, le fichier de vidage de mémoire est stocké dans le répertoire MSSQL\LOG\ de l’instance SQL.

Comment modifier le chemin d’accès par défaut

Si, par exemple, la taille du fichier de vidage est trop grande, vous pouvez modifier le chemin en procédant comme suit :

Ouvrez le Gestionnaire de configuration SQL Server.
Sous SQL Server Services, recherchez l’instance SQL Server en cours d’investigation.
Cliquez avec le bouton droit sur cette entrée, sélectionnez Propriétés, puis accédez à l’onglet Avancé .
Remplacez ce répertoire de vidage par le chemin souhaité, puis sélectionnez OK.
Redémarrez SQL Server (le cas échéant) pour que le nouveau paramètre prenne effet.

Lorsque l’outil Sqldumper.exe est utilisé manuellement pour générer un fichier de vidage pour n’importe quelle application Windows, le fichier de vidage peut être aussi volumineux que la mémoire que l’application Windows utilise actuellement. Assurez-vous que suffisamment d’espace disque est disponible sur le lecteur dans lequel Sqldumper.exe écrit le fichier de vidage.

Spécifier un dossier de sortie personnalisé dans la commande

Vous pouvez spécifier le répertoire dans lequel vous souhaitez que l’outil Sqldumper.exe écrive le fichier de vidage. Le répertoire doit déjà exister avant d’exécuter Sqldumper.exe. Sinon, Sqldumper.exe échoue. N’utilisez pas de chemin UNC (Universal Naming Convention) comme emplacement pour le fichier de vidage. Les étapes suivantes fournissent un exemple de spécification de l’emplacement du fichier mini-dump :

Sélectionnez Démarrer>l’exécution, tapez cmd, puis sélectionnez OK.

À l’invite de commandes, tapez la commande suivante et appuyez sur Entrée :

cd <SQLServerInstall Drive>:\Program Files\Microsoft SQL Server\<number>\Shared

À l’invite de commandes, tapez la commande suivante et appuyez sur Entrée :
```
Sqldumper.exe ProcessID 0 0x0128 0 <MdumpPath>
```
Note

<MdumpPath> est un espace réservé pour le répertoire dans lequel vous souhaitez que l’outil Sqldumper.exe écrive le fichier de vidage. Par défaut, le fichier est écrit dans le dossier actif.

Si vous spécifiez un fichier de vidage complet ou un fichier de vidage filtré à générer, Sqldumper.exe peut prendre plusieurs minutes pour générer le fichier de vidage. Le temps nécessaire dépend des variables suivantes :

Quantité de mémoire que Sqlservr.exe utilise actuellement.
Vitesse d’écriture du lecteur utilisé par l’outil pour stocker le fichier de vidage.

Pendant ce temps, l’outil Sqldumper.exe ne traite pas les commandes. Vous remarquerez que le serveur cesse de répondre. En outre, un basculement de cluster peut se produire.

Spécifications relatives aux autorisations

Pour exécuter Sqldumper.exe, vous devez vous connecter à Windows à l’aide de l’une des méthodes suivantes :

Utilisez un compte membre du groupe de l’administrateur sur l’ordinateur.
Utilisez le même compte d’utilisateur sous lequel le service SQL Server est en cours d’exécution.

Pour que l’outil Sqldumper.exe fonctionne correctement via le Bureau à distance ou les services Terminal Services, vous devez démarrer bureau à distance ou services terminal en mode console. Par exemple, pour démarrer le Bureau à distance en mode console, sélectionnez Démarrer>l’exécution, tapez mstsc /console, puis sélectionnez OK. Si le serveur cible exécute Windows 2000, l’option /console est ignorée en mode silencieux. Vous pouvez vous connecter au serveur via le Bureau à distance, mais vous n’utiliserez pas la session de console.

Si vous constatez qu’aucun fichier de vidage n’a été généré dans le dossier actif après avoir exécuté Sqldumper.exe, vérifiez la sortie de ligne de commande générée par l’outil pour identifier la cause potentielle de l’échec. Ces informations sont également consignées dans le fichier Sqldumper_errorlog.log dans le répertoire actif. Voici deux messages d’erreur possibles et leurs causes :

Message	Cause
« Échec de l'0x57 OpenProcess - Le paramètre est incorrect »	Un ID de processus non valide a été passé à l’utilitaire Sqldumper.exe.
« Valeur non valide pour l’ID de thread - <Erreur de paramètre> non valide »	Un paramètre non valide a été passé à l’utilitaire Sqldumper.exe.

Si un message d’erreur semblable à l’un des éléments suivants est généré, vous pouvez ignorer ce message en toute sécurité :

« Type de rappel inconnu pendant minidump 6 »
« Type de rappel inconnu pendant minidump 7 »

Impact de la génération de vidage

Lorsqu’un fichier de vidage d’un processus en mode utilisateur est demandé (comme indiqué dans cet article, par opposition aux vidages du noyau du système d’exploitation, qui sont en dehors de notre portée), le processus cible (ici SQLServer.exe) est figé pendant la durée nécessaire pour sérialiser le contenu de vidage sur sa cible de fichier.

Figé signifie que le processus ne pourra pas exécuter de demande d’utilisateur ou d’opération interne, y compris tout mécanisme d’interrogation des ressources tel que l’implémentation de l’IsAlive et look Alive de Windows Clustering (voir la section Vidages mémoire sur les basculements de cluster pour plus d’informations sur la façon de gérer cette situation). Tout délai d’attente qui s’appuie sur le temps de l’horloge murale peut également être violé en raison du gel.

En fonction de l’instruction précédente, la durée du gel est le facteur critique ici, piloté par les éléments suivants :

Type de vidage sélectionné.
La taille du processus SQL Server en mémoire, qui, dans le cas d’une seule instance active exécutant des paramètres par défaut, est souvent proche de la ram physique totale du serveur.
Performances du disque utilisé comme cible pour le vidage.

En outre, la taille du fichier de vidage sur le disque doit être planifiée, en particulier si plusieurs vidages sont possibles et si les types de vidages volumineux non par défaut sont sélectionnés. Veillez à passer en revue les types de vidage pour savoir ce qu’il faut attendre. Par défaut, certaines méthodes de vidage créent le vidage dans le dossier \Log de l’instance SQL Server, qui, dans la configuration simple par défaut, serait également le disque système et le disque de journal+données pour SQL Server. L’apport de ce disque à la saturation a un impact grave sur la disponibilité de SQL Server et/ou du système.

Gérer l’impact sur les systèmes en cluster

Le processus est suspendu temporairement pendant la génération de vidage. Cela peut affecter la disponibilité du service SQL Server et déclencher le basculement des ressources dans les contextes Always On (instance de cluster de basculement et groupe de disponibilité). La génération de vidage de différents processus a un impact différent sur les ressources. Lisez attentivement les sections Impact de la génération de vidage et des types de vidage.

Lorsque vous capturez un vidage SQL Server sur une instance en cluster de basculement ou une instance de groupe de disponibilité de SQL Server, le serveur SQL Server ou le groupe de disponibilité en cluster peut basculer vers un autre nœud si le vidage prend trop de temps. Cela peut être particulièrement problématique sur les systèmes qui utilisent de grandes quantités de RAM ou si vous générez un vidage de mémoire complète ou filtrée. Pour empêcher le basculement, utilisez les paramètres suivants avant de capturer le fichier de vidage. La modification peut être rétablie une fois qu’un fichier de vidage est pris :

Pour l’instance en cluster de basculement (FCI) :
- Cliquez avec le bouton droit sur la ressource SQL Server dans l’administrateur de cluster, sélectionnez Si la ressource échoue, ne redémarrez pas sous l’onglet Stratégies .
- Sous l’onglet Propriétés, augmentez le délai d’expiration du contrôle d’intégrité. Par exemple, définissez la valeur de la propriété sur 180 secondes ou ultérieures. Si ce délai d’expiration est atteint, la stratégie Si la ressource échoue, ne redémarrez pas est ignorée et la ressource est redémarrée.
- Sous l’onglet Propriétés , remplacez la valeur FailureConditionLevel par zéro.
Pour le groupe de disponibilité, appliquez tous les paramètres suivants :
- Augmentez le délai d’expiration de session, par exemple, 120 secondes pour tous les réplicas. Dans SQL Server Management Studio (SSMS), cliquez avec le bouton droit sur le réplica à configurer, puis sélectionnez Propriétés. Remplacez le champ Délai d’expiration de session (secondes) par 120 secondes. Pour plus d’informations, consultez Modifier la période d’expiration de session pour un réplica de disponibilité (SQL Server).
- Modifiez le basculement automatique de tous les réplicas en basculement manuel. Dans SSMS, cliquez avec le bouton droit sur le réplica, sélectionnez Propriétés et modifiez le basculement automatique de tous les réplicas en basculement manuel sous l’onglet Propriétés. Pour plus d’informations, consultez Modifier le mode de basculement d’un réplica de disponibilité (SQL Server).
- Augmentez le leaseTimeout à 60 000 ms (60 secondes) et remplacez HealthCheckTimeout par 90 000 ms (90 secondes). Dans l’administrateur de cluster, cliquez avec le bouton droit sur la ressource de groupe de disponibilité, sélectionnez Propriétés, puis basculez vers l’onglet Propriétés pour modifier les deux paramètres. Pour plus d’informations, consultez Configurer les paramètres de propriété HealthCheckTimeout.

Améliorations apportées aux produits pour réduire l’impact sur SQL Server

Quatre améliorations majeures sont ajoutées aux versions récentes de SQL Server pour réduire la taille du fichier de vidage et/ou le temps de génération du vidage de la mémoire :

Mécanisme de filtrage bitmap
Élimination des vidages répétés sur le même problème
Sortie raccourcie dans le journal des erreurs
Compression parallèle des vidages de mémoire

Mécanisme de filtrage bitmap

SQL Server alloue une bitmap qui effectue le suivi des pages mémoire à exclure d’une image mémoire filtrée. Sqldumper.exe lit la bitmap et filtre les pages sans avoir besoin de lire d’autres métadonnées du gestionnaire de mémoire. Les messages suivants s’affichent dans le journal des erreurs SQL Server lorsque la bitmap est activée ou désactivée respectivement :

Page exclusion bitmap is enabled. et Page exclusion bitmap is disabled.

SQL Server 2016

À compter de SQL Server 2016 SP2 CU13, le filtrage bitmap est activé par défaut.
SQL Server 2017
- Cela n’est pas disponible dans RTM via CU15.
- Dans SQL Server 2017 CU16, vous pouvez activer le filtrage bitmap via T8089 et le désactiver en désactivant T8089.
- À compter de SQL Server 2017 CU20, le filtrage bitmap est activé par défaut. L’indicateur de trace T8089 ne s’applique plus et est ignoré s’il est activé. Le filtrage bitmap peut être désactivé via T8095.
SQL Server 2019

Cette option est activée par défaut dans SQL Server 2019 RTM. Elle peut être désactivée via T8095.

Élimination des vidages répétés sur le même problème

Les vidages de mémoire répétés sur le même problème sont éliminés. À l’aide d’une signature de pile, le moteur SQL effectue le suivi si une exception s’est déjà produite et ne produit pas de nouveau vidage de mémoire s’il en existe déjà un. Cela s’applique aux violations d’accès, au dépassement de capacité de pile, aux assertions et aux exceptions d’altération des index. Cela réduit considérablement la quantité d’espace disque utilisé par les vidages de mémoire et ne fige pas temporairement le processus pour générer un vidage. Cette opération a été ajoutée dans SQL Server 2019.

Sortie raccourcie dans le journal des erreurs

Le contenu généré dans le journal des erreurs SQL Server à partir d’un vidage de mémoire unique peut non seulement être écrasant, mais il peut également ralentir le processus de génération d’un vidage de mémoire en raison du temps nécessaire pour sérialiser toutes ces informations dans un format texte dans le journal des erreurs. Dans SQL Server 2019, le contenu stocké dans le journal des erreurs lors de la génération de vidage a été considérablement réduit et il peut ressembler à ceci :

DateTimespidS pid    **Dump thread - spid = 0, EC = 0x0000015C7169BF40
DateTimespidS pid    *
DateTimespidS pid    *User initiated stack dump. This is not a server exception dump.
DateTimespidS pid    *
DateTimespidS pid    Stack Signature for the dump is 0x00000000788399E5
DateTimespidS pid    External dump process return code 0x20000001.
External dump process returned no errors.

Précédemment, SQL Server imprime des informations pour chaque session ou thread lorsqu’un vidage manuel a été déclenché par l’utilisateur par exemple.

Compression parallèle des vidages de mémoire

Pour générer des vidages plus rapidement et les réduire en taille, une fonctionnalité de vidage de mémoire compressée a été introduite dans SQL Server 2022 CU8 et SQL Server 2019 CU23. Lorsqu’elle est activée, Sqldumper.exe crée plusieurs threads pour lire simultanément la mémoire d’un processus, la compresse, puis l’enregistre dans le fichier de vidage. Cette compression parallèle multithread réduit la taille du fichier et accélère le processus de vidage lorsqu’il est utilisé avec des vidages complets et filtrés.

Vous pouvez activer l’indicateur de trace 2610 pour activer le vidage de la mémoire compressée :

DBCC TRACEON (2610,-1)
GO
DBCC STACKDUMP with FILTERED_DUMP
GO
DBCC TRACEOFF (2610,-1)

Vous pouvez également ajouter -T2610 en tant que paramètre de démarrage à votre instance SQL Server afin qu’elle crée toujours des vidages de mémoire compressés.

Si vous exécutez manuellement Sqldumper.exe, vous pouvez utiliser le -zdmp paramètre pour capturer un vidage de mémoire compressé. Par exemple :

Sqldumper.exe <ProcessID> 0 0x8100 0 d:\temp -zdmp

Vous pouvez également limiter le nombre de cœurs Sqldumper.exe pouvez utiliser pour créer le vidage compressé à l’aide du -cpu:X paramètre, où X est le nombre de processeurs. Ce paramètre est disponible uniquement lorsque vous exécutez manuellement Sqldumper.exe à partir de la ligne de commande :

Sqldumper.exe <ProcessID> 0 0x8100 0 d:\temp -zdmp -cpu:8

Facteurs qui empêchent ou retardent la création de vidages de mémoire

Les facteurs suivants sont connus pour provoquer des retards ou empêcher la création de vidages de mémoire.

Le chemin d’E/S où les vidages de mémoire sont écrits fonctionne mal. Dans ce cas, pour examiner et résoudre les performances des E/S de disque, il s’agit de l’étape logique suivante.
Un antivirus ou un autre logiciel de surveillance interfère avec SQLDumper.exe. Dans certains cas, un logiciel tiers détoure la fonction ReadProcessMemory . Cela peut augmenter considérablement la durée de vidage. Pour résoudre la plupart de ces problèmes, désactivez le logiciel interférant ou ajoutez SQLDumper.exe à une liste d’exclusions.

Types de vidage

Les méthodes suivantes peuvent être utilisées pour générer trois types de vidages différents : les mini-vidages, les vidages complets et les vidages filtrés.

Mini dumps avec mémoire référencée

Ce type de vidage de mémoire est un instantané de tous les threads actifs du processus (« piles de threads »), ainsi qu’un extrait limité de la mémoire référencée par les piles de threads et d’autres processus clés ou données de thread. Ils sont généralement de taille de quelques mégaoctets et sont rapides à générer (de moins d’une seconde à quelques secondes). Même les systèmes serveurs plus volumineux (avec des centaines de processeurs qui entraînent indirectement un grand nombre de threads dans le processus SQL Server) dépassent rarement 20 à 30 Mo : la taille d’un mini-vidage ne croît pas avec la taille du processus SQL Server. Ce type de vidage est le type par défaut utilisé par SQL Server lors de la génération automatique de vidages de mémoire sur les exceptions, les problèmes de planificateur, les problèmes de verrou, la corruption de base de données et les assertions.

Note

SQL Server, dans le cadre de son instrumentation intégrée, génère des « mini-vidages de diagnostic » automatisés dans certaines situations spécifiques. Cette opération est donc considérée comme suffisamment sûre pour que SQL Server puisse le déclencher automatiquement si nécessaire.

Vidages complets

Un vidage de mémoire complète est une copie complète de l’espace de processus cible actif. Cela inclurait donc l’état de tous les threads, toutes les mémoires allouées au processus et tous les modules chargés. Les vidages complets auront donc une taille, qui est à peu près la même que le processus SQL Server, qui à son tour peut être presque aussi grande que la ram système totale. Sur les serveurs volumineux dédiés à une seule instance SQL Server qui peut signifier un fichier, qui est de plusieurs centaines de gigaoctets ou plus. Inutile de dire qu’un tel fichier prendra beaucoup de temps pour générer et provoquera donc un gel prolongé. Les performances du disque pour la cible de fichier du vidage influenceront considérablement le temps de congélation. Ce type de vidage est rarement utilisé pour SQL Server aujourd’hui, comme décrit dans l’explication suivante.

Vidages filtrés

À mesure que la taille de ram des serveurs standard exécutant SQL Server augmente constamment, les vidages complets deviennent plus complexes. Les vidages filtrés sont donc implémentés. Un vidage filtré est un sous-ensemble d’un vidage complet, où de grandes zones de mémoire SQL Server sont exclues à la volée et non écrites sur le disque. En règle générale, la mémoire exclue n’apporte aucune valeur ajoutée à la résolution des problèmes. Par exemple, les pages de données/index et certains caches internes tels que les pages de données Hekaton et la mémoire du pool de journaux. Ce vidage filtré entraîne un fichier plus petit qu’un vidage complet, mais le vidage conserve toujours presque toute son utilité. Les vidages filtrés ont remplacé les vidages complets comme option préférée dans une grande majorité des situations où les mini-vidages ne sont pas suffisants. La diminution de la taille peut varier par rapport à un vidage complet, mais il s’agit toujours d’un fichier assez volumineux, qui est souvent de 30 à 60 % de la taille du processus SQL Server. Par conséquent, il est préférable de planifier une taille possible aussi grande qu’un vidage complet comme une meilleure option, ce qui laisse une bonne marge de sécurité. Un vidage filtré peut ne pas nécessairement être nécessairement plus rapide à générer qu’un vidage complet dans tous les cas : il s’agit de savoir si les gains liés au nombre d’E/S évitées dépassent le temps nécessaire pour implémenter la logique de filtre (la vitesse du disque et la vitesse processeur/RAM influenceront cela).

Vous pouvez utiliser la requête suivante pour obtenir une estimation approximative de la taille de vidage filtrée. Bien que la plupart des données ou des pages d’index soient exclues du vidage, celles qui sont exclusivement bloquées et modifiées ne seront pas omises.

SELECT SUM(pages_kb)
FROM sys.dm_os_memory_clerks
WHERE type != 'MEMORYCLERK_SQLBUFFERPOOL'

Étant donné que vous pouvez utiliser Sqldumper.exe pour générer un fichier de vidage à la demande pour n’importe quelle application Microsoft Windows, vous pouvez envisager d’utiliser l’option de vidage filtrée. Toutefois, un fichier de vidage filtré est applicable et significatif uniquement dans le contexte de SQL Server. Vous pouvez toujours générer un mini-vidage, un fichier de vidage complet ou des applications non-SQL Server avec succès.

Le processus SQL Server appelle l’outil Sqldumper.exe en interne pour générer un fichier de vidage lorsque le processus rencontre des exceptions. SQL Server transmet des paramètres à Sqldumper.exe. Vous pouvez utiliser des indicateurs de trace pour modifier les paramètres transmis par SQL Server à l’outil par défaut lorsqu’une exception ou une assertion se produit. Ces indicateurs de trace sont comprises entre 2540 et 2559. Vous pouvez utiliser l’un de ces indicateurs de trace pour modifier le type de vidage par défaut SQLDumper.exe générer (la valeur par défaut est un mini-vidage avec une mémoire référencée). Par exemple :

Indicateur de trace 2551 : produit un vidage de mémoire filtrée.
Indicateur de trace 2544 : produit un vidage de mémoire complète.
Indicateur de trace 8026 : SQL Server efface un déclencheur de vidage après avoir généré le vidage une seule fois.

Si deux indicateurs de trace ou plus sont actifs, l’option indiquant que le plus grand vidage de mémoire est respecté. Par exemple, si des indicateurs de trace 2551 et 2544 sont utilisés, SQL Server crée un vidage de mémoire complète.

Générer un vidage de mémoire sur les basculements de cluster

Dans les scénarios de basculement de cluster, la DLL de ressource SQL Server peut obtenir un fichier de vidage avant le basculement pour faciliter la résolution des problèmes. Lorsque la DLL de ressource SQL Server détermine qu’une ressource SQL Server a échoué, elle utilise l’utilitaire Sqldumper.exe pour obtenir un fichier dump du processus SQL Server. Pour vous assurer que l’outil Sqldumper.exe génère correctement le fichier de vidage, vous devez définir les trois propriétés suivantes comme prérequis :

SqlDumperDumpTimeOut

Délai d’expiration spécifié par l’utilisateur. La DLL de ressource attend que le fichier de vidage soit terminé avant que la DLL de ressource arrête le service SQL Server.
SqlDumperDumpPath

Emplacement où l’outil Sqldumper.exe génère le fichier de vidage.
SqlDumperDumpFlags

Indicateurs que Sqldumper.exe utilise.

Si l’une des propriétés n’est pas définie, Sqldumper.exe ne peut pas générer le fichier de vidage. Un message d’avertissement est enregistré à la fois dans le journal des événements et dans le journal du cluster chaque fois que la ressource est mise en ligne.

Configuration du cluster pour SQLDumper sur SQL Server 2012 et versions ultérieures

Vous pouvez utiliser la ALTER SERVER CONFIGURATION commande (T-SQL) pour modifier ces propriétés. Par exemple :

ALTER SERVER CONFIGURATION SET FAILOVER CLUSTER PROPERTY SqlDumperDumpTimeOut = 0;
ALTER SERVER CONFIGURATION SET FAILOVER CLUSTER PROPERTY SqlDumperDumpPath = 'C:\temp\';
ALTER SERVER CONFIGURATION SET FAILOVER CLUSTER PROPERTY SqlDumperDumpFlags = 296;

Vous pouvez également utiliser des scripts PowerShell. Par exemple, pour une instance nommée SQL2017AG :

Get-ClusterResource -Name "SQL Server (SQL2017AG)" | Set-ClusterParameter -Name "SqlDumperDumpPath" -Value "C:\temp"
Get-ClusterResource -Name "SQL Server (SQL2017AG)" | Set-ClusterParameter -Name "SqlDumperDumpFlags" -Value 296
Get-ClusterResource -Name "SQL Server (SQL2017AG)" | Set-ClusterParameter -Name "SqlDumperDumpTimeOut" -Value 0

Pour vérifier si les paramètres sont appliqués, vous pouvez exécuter la commande PowerShell suivante :

Get-ClusterResource -Name "SQL Server (SQL2017AG)" | Get-ClusterParameter

Configuration du cluster pour SQLDumper sur SQL Server 2008/2008 R2 ou Windows 2012 et versions antérieures

Pour définir les propriétés de l’utilitaire Sqldumper.exe pour le basculement de cluster à l’aide de la commande de ressource de cluster, procédez comme suit :

Sélectionnez Démarrer>l’exécution, tapez cmd, puis sélectionnez OK.
Pour chaque propriété, tapez la commande correspondante à l’invite de commandes, puis appuyez sur Entrée :
- La propriété SqlDumperDumpFlags
  
  Pour définir la SqlDumperDumpFlags propriété d’un fichier de vidage spécifique, tapez la commande correspondante à l’invite de commandes, puis appuyez sur Entrée :
  - Tous les fichiers de vidage complet du thread
    - Instance par défaut
```
cluster resource "SQL Server" /priv SqlDumperDumpFlags = 0x01100
```
    - Instance nommée
```
cluster resource "SQL Server (INSTANCE1)" /priv SqlDumperDumpFlags = 0x01100
```
  - Tous les fichiers de mini-vidage de thread
    - Instance par défaut
```
cluster resource "SQL Server" /priv SqlDumperDumpFlags = 0x0120
```
    - Instance nommée
```
cluster resource "SQL Server (INSTANCE1)" /priv SqlDumperDumpFlags = 0x0120
```
  - Filtrage de tous les fichiers de vidage de thread
    - Instance par défaut
```
cluster resource "SQL Server" /priv SqlDumperDumpFlags = 0x8100
```
    - Instance nommée
```
cluster resource "SQL Server  (INSTANCE1)" /priv SqlDumperDumpFlags = 0x8100
```
- La propriété SqlDumperDumpPath
```
cluster resource "SQL Server" /priv SqlDumperDumpPath = <DirectoryPath>
```
  Note
  
  <DirectoryPath> est un espace réservé pour le répertoire dans lequel le fichier de vidage sera généré, et il doit être spécifié entre guillemets ( » « ).
- La propriété SqlDumperDumpTimeOut
```
cluster resource "SQL Server" /priv SqlDumperDumpTimeOut = <Timeout>
```
  Note
  
  <Le délai d’expiration> est un espace réservé pour le délai d’expiration en millisecondes (ms).

Le temps nécessaire à l’outil pour générer un fichier de vidage d’un processus SQL Server dépend de la configuration de l’ordinateur. Pour un ordinateur avec une grande quantité de mémoire, le temps peut être significatif. Pour estimer le temps nécessaire au processus, utilisez l’outil Sqldumper.exe pour générer manuellement un fichier de vidage. Les valeurs valides de la SqlDumperDumpTimeOut propriété sont comprises entre 10 000 ms et MAXDWORD. MAXDWORD représente la valeur la plus élevée dans la plage du type de données DWORD (4294967295).

Pour vérifier que les paramètres sont activés, vous pouvez exécuter la commande suivante :

cluster resource "SQL Server" /priv

Supprimer les propriétés de Sqldumper.exe pour le basculement de cluster

Pour supprimer les propriétés de l’outil Sqldumper.exe pour le basculement de cluster, procédez comme suit :

Sélectionnez Démarrer>l’exécution, tapez cmd, puis sélectionnez OK.

Pour une propriété spécifique, tapez la commande correspondante à l’invite de commandes, puis appuyez sur Entrée :

La propriété SqlDumperDumpFlags

Instance par défaut

  cluster resource "SQL Server" /priv:SqlDumperDumpFlags /usedefault

Instance nommée

  cluster resource "SQL Server (INSTANCE1)" /priv:SqlDumperDumpFlags /usedefault

La propriété SqlDumperDumpPath

Instance par défaut

cluster resource "SQL Server" /priv:SqlDumperDumpPath /usedefault

Instance nommée

cluster resource "SQL Server (INSTANCE1)" /priv:SqlDumperDumpPath /usedefault

La propriété SqlDumperDumpTimeOut

Instance par défaut

cluster resource "SQL Server" /priv:SqlDumperDumpTimeOut /usedefault

Instance nommée

cluster resource "SQL Server (INSTANCE1)" /priv:SqlDumperDumpTimeOut /usedefault

Utilisation de DBCC STACKDUMP

La DBCC STACKDUMP commande peut vous aider à créer un vidage de mémoire dans le répertoire LOG de votre installation d’instance SQL Server. Par défaut, la commande crée un minidump avec tous les threads, qui a une taille limitée et est suffisante pour refléter l’état du processus SQL Server. Exécutez la commande suivante dans un client SQL Server :

DBCC STACKDUMP

Pour connaître les fonctionnalités étendues de DBCC STACKDUMP SQL Server 2019, consultez la fonctionnalité DBCC STACKDUMP étendue introduite dans SQL Server 2019.

Pour activer cette méthode pour créer un vidage filtré, activez les indicateurs de trace 2551 à l’aide de la commande suivante :

DBCC TRACEON(2551, -1)
GO
DBCC STACKDUMP

Pour créer un vidage complet, utilisez l’indicateur de trace 2544.

Une fois le fichier de vidage obtenu, vous devez désactiver l’indicateur de trace à l’aide de la commande DBCC TRACEOFF (<TraceNumber>, -1); pour éviter de mettre à niveau par inadvertance toutes les minidumps de diagnostic automatique SQL Server vers des vidages plus volumineux. Dans la commande, <TraceNumber> est l’indicateur de trace que vous avez précédemment activé comme 2551 ou 2544. Par exemple :

DBCC TRACEOFF(2551, -1)

Si vous ne savez pas quel indicateur de trace reste actif, exécutez la commande suivante :

DBCC TRACESTATUS(-1)

Un jeu de résultats vide indique qu’aucun indicateur de trace n’est actif. À l’inverse, si 2551 est toujours actif, vous verrez :

TraceFlag	État	Global	Session
2551	1	1	0

Note

Activé traceflag par DBCC TRACEON sont réinitialisés (supprimés) après le redémarrage d’un service.

Fonctionnalité DBCC STACKDUMP étendue introduite dans SQL Server 2019

À compter de SQL Server 2019 CU2, la DBCC STACKDUMP commande a été étendue pour prendre en charge la génération de vidages de différents types : mini, filtré et vidages complets. Cette commande élimine la nécessité d’utiliser des indicateurs de trace. Il vous permet également de limiter la sortie de texte dans l’autre fichier texte généré avec le vidage de la mémoire. Cela peut fournir un gain de performances visible dans le temps nécessaire SQLDumper.exe pour générer un vidage de mémoire.

DBCC STACKDUMP WITH MINI_DUMP | FILTERED_DUMP | FULL_DUMP [, TEXT_DUMP = LIMITED | DETAILED]

Il TEXT_DUMP = LIMITED s’agit de l’option par défaut. Si vous souhaitez recevoir une sortie détaillée dans le fichier SQLDump000X.txt , vous pouvez utiliser TEXT_DUMP = DETAILED.

Pour générer un vidage filtré avec une sortie limitée dans le fichier .txt , exécutez la commande suivante :

DBCC STACKDUMP WITH FILTERED_DUMP , TEXT_DUMP = LIMITED

Comment utiliser un script PowerShell pour générer un fichier de vidage avec SQLDumper

Enregistrez le code suivant sous la forme d’un fichier PS1, par exemple SQLDumpHelper.ps1 :

Détails du code

$isInt = $false
$isIntValDcnt = $false
$isIntValDelay = $false
$SqlPidInt = 0
$NumFoler = ""
$OneThruFour = ""
$SqlDumpTypeSelection = ""
$SSASDumpTypeSelection = ""
$SSISDumpTypeSelection = ""
$SQLNumfolder = 0
$SQLDumperDir = ""
$OutputFolder = ""
$DumpType = "0x0120"
$ValidPid
$SharedFolderFound = $false
$YesNo = ""
$ProductNumber = ""
$ProductStr = ""

Write-Host ""
Write-Host "`******************************************************************"
Write-Host "This script helps you generate one or more SQL Server memory dumps"
Write-Host "It presents you with choices on:`
            -target SQL Server process (if more than one)
            -type of memory dump
            -count and time interval (if multiple memory dumps)
You can interrupt this script using CTRL+C"
Write-Host "***********************************************************************"

# check for administrator rights
# debugging tools like SQLDumper.exe require Admin privileges to generate a memory dump

if (-not ([Security.Principal.WindowsPrincipal] [Security.Principal.WindowsIdentity]::GetCurrent()).IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator))
{
    Write-Warning "Administrator rights are required to generate a memory dump!`nPlease re-run this script as an Administrator!"
    return
}

# what product would you like to generate a memory dump
while ($true)
{
    Write-Host "Which product would you like to generate a memory dump of?" -ForegroundColor Yellow
    Write-Host "1) SQL Server"
    Write-Host "2) SSAS (Analysis Services)"
    Write-Host "3) SSIS (Integration Services)"
    Write-Host "4) SSRS (Reporting Services)"
    Write-Host "5) SQL Server Agent"
    Write-Host ""
    $ProductNumber = Read-Host "Enter 1-5>"

    if ($ProductNumber -in 1,2,3,4,5)
    {
        break
    }
    Write-Host "`nPlease enter a valid number from list above!`n"
    Start-Sleep -Milliseconds 300
}

if ($ProductNumber -eq "1")
{
    $SqlTaskList = Tasklist /SVC /FI "imagename eq sqlservr*" /FO CSV | ConvertFrom-Csv
    $ProductStr = "SQL Server"
}
elseif ($ProductNumber -eq "2")
{
    $SqlTaskList = Tasklist /SVC /FI "imagename eq msmdsrv*" /FO CSV | ConvertFrom-Csv
    $ProductStr = "SSAS (Analysis Services)"
}
elseif ($ProductNumber -eq "3")
{
    $SqlTaskList = Tasklist /SVC /FI "imagename eq msdtssrvr*" /FO CSV | ConvertFrom-Csv
    $ProductStr = "SSIS (Integration Services)"
}
elseif ($ProductNumber -eq "4")
{
    $SqlTaskList = Tasklist /SVC /FI "imagename eq reportingservicesservice*" /FO CSV | ConvertFrom-Csv
    $ProductStr = "SSRS (Reporting Services)"
}
elseif ($ProductNumber -eq "5")
{
    $SqlTaskList = Tasklist /SVC /FI "imagename eq sqlagent*" /FO CSV | ConvertFrom-Csv
    $ProductStr = "SQL Server Agent"
}

if ($SqlTaskList.Count -eq 0)
{
    Write-Host "There are currently no running instances of $ProductStr. Exiting..." -ForegroundColor Green
    break
}

# if multiple SQL Server instances, get the user to input PID for desired SQL Server
if ($SqlTaskList.Count -gt 1)
{
    Write-Host "More than one $ProductStr instance found."

    $SqlTaskList | Select-Object PID, "Image name", Services | Out-Host

    # check input and make sure it is a valid integer
    while ($true)
    {
        Write-Host "Please enter the PID for the desired SQL service from list above" -ForegroundColor Yellow
        $SqlPidStr = Read-Host ">"

        if( $SqlPidStr -in $SqlTaskList.PID)
        {
            $SqlPidInt = [int]$SqlPidStr
            break
        }
    }

    Write-Host "Using PID=$SqlPidInt for generating a $ProductStr memory dump" -ForegroundColor Green
    Write-Host ""

}
else # if only one SQL Server/SSAS on the box, go here
{
    $SqlTaskList | Select-Object PID, "Image name", Services | Out-Host
    $SqlPidInt = [convert]::ToInt32($SqlTaskList.PID)

    Write-Host "Using PID=", $SqlPidInt, " for generating a $ProductStr memory dump" -ForegroundColor Green
    Write-Host ""
}

# dump type

if ($ProductNumber -eq "1")  # SQL Server memory dump
{
    # ask what type of SQL Server memory dump
    while($true)
    {
        Write-Host "Which type of memory dump would you like to generate?" -ForegroundColor Yellow
        Write-Host "1) Mini-dump"
        Write-Host "2) Mini-dump with referenced memory " -NoNewLine; Write-Host "(Recommended)"
        Write-Host "3) Filtered dump " -NoNewline; Write-Host "(Not Recommended)" -ForegroundColor Red
        Write-Host "4) Full dump  " -NoNewline; Write-Host "(Do Not Use on Production systems!)" -ForegroundColor Red
        Write-Host ""
        $SqlDumpTypeSelection = Read-Host "Enter 1-4>"

        if ($SqlDumpTypeSelection -in 1,2,3,4)
        {
            break
        }
        Write-Host "`nPlease enter a valid type of memory dump!`n"
        Start-Sleep -Milliseconds 300
    }

    Write-Host ""

    switch ($SqlDumpTypeSelection)
    {
        "1" { $DumpType="0x0120"; break }
        "2" { $DumpType="0x0128"; break }
        "3" { $DumpType="0x8100"; break }
        "4" { $DumpType="0x01100"; break }
        default { "0x0120"; break }
    }
}
elseif ($ProductNumber -eq "2")  # SSAS dump
{
    # ask what type of SSAS memory dump
    while($true)
    {
        Write-Host "Which type of memory dump would you like to generate?" -ForegroundColor Yellow
        Write-Host "1) Mini-dump"
        Write-Host "2) Full dump  " -NoNewline; Write-Host "(Do Not Use on Production systems!)" -ForegroundColor Red
        Write-Host ""
        $SSASDumpTypeSelection = Read-Host "Enter 1-2>"

        if ($SSASDumpTypeSelection -in 1,2)
        {
            break
        }
        Write-Host "`nPlease enter a valid type of memory dump!`n"
        Start-Sleep -Milliseconds 300
    }

    Write-Host ""

    switch ($SSASDumpTypeSelection)
    {
        "1" {$DumpType="0x0";break}
        "2" {$DumpType="0x34";break}
        default {"0x0120"; break}
    }
}
elseif ($ProductNumber -in 3,4,5)  # SSIS/SSRS/SQL Agent dump
{
    # ask what type of SSIS memory dump
    while($true)
    {
        Write-Host "Which type of memory dump would you like to generate?" -ForegroundColor Yellow
        Write-Host "1) Mini-dump"
        Write-Host "2) Full dump"
        Write-Host ""
        $SSISDumpTypeSelection = Read-Host "Enter 1-2>"

        if ($SSISDumpTypeSelection -in 1,2)
        {
            break
        }
        Write-Host "`nPlease enter a valid type of memory dump!`n"
        Start-Sleep -Milliseconds 300
    }

    Write-Host ""

    switch ($SSISDumpTypeSelection)
    {
        "1" { $DumpType="0x0"; break }
        "2" { $DumpType="0x34"; break }
        default { "0x0120"; break }
    }
}

# Sqldumper.exe PID 0 0x0128 0 c:\temp
# output folder
while($OutputFolder -eq "" -or !(Test-Path -Path $OutputFolder))
{
    Write-Host ""
    Write-Host "Where would your like the memory dump stored (output folder)?" -ForegroundColor Yellow
    $OutputFolder = Read-Host "Enter an output folder with no quotes (e.g. C:\MyTempFolder or C:\My Folder)"
    if ($OutputFolder -eq "" -or !(Test-Path -Path $OutputFolder))
    {
        Write-Host "'" $OutputFolder "' is not a valid folder. Please, enter a valid folder location" -ForegroundColor Yellow
    }
}

# strip the last character of the Output folder if it is a backslash "\". Else Sqldumper.exe will fail
if ($OutputFolder.Substring($OutputFolder.Length-1) -eq "\")
{
    $OutputFolder = $OutputFolder.Substring(0, $OutputFolder.Length-1)
    Write-Host "Stripped the last '\' from output folder name. Now folder name is  $OutputFolder"
}

# find the highest version of SQLDumper.exe on the machine
$NumFolder = dir "C:\Program Files\Microsoft SQL Server\1*" | Select-Object @{name = "DirNameInt"; expression={[int]($_.Name)}}, Name, Mode | Where-Object Mode -Match "da*" | Sort-Object DirNameInt -Descending

for( $j=0; $j -lt $NumFolder.Count; $j++)
{
    $SQLNumfolder = $NumFolder.DirNameInt[$j]   # start with the highest value from sorted folder names - latest version of dumper
    $SQLDumperDir = "C:\Program Files\Microsoft SQL Server\" + $SQLNumfolder.ToString() + "\Shared\"
    $TestPathDumperDir = $SQLDumperDir + "sqldumper.exe"

    if (Test-Path -Path $SQLDumperDir)
    {
        break
    }
}

# build the SQLDumper.exe command e.g. (Sqldumper.exe 1096 0 0x0128 0 c:\temp\)

$cmd = "$([char]34)"+$SQLDumperDir + "sqldumper.exe$([char]34)"
$arglist = $SqlPidInt.ToString() + " 0 " +$DumpType +" 0 $([char]34)" + $OutputFolder + "$([char]34)"
Write-Host "Command for dump generation: ", $cmd, $arglist -ForegroundColor Green

# do-we-want-multiple-dumps section
Write-Host ""
Write-Host "This utility can generate multiple memory dumps, at a certain interval"
Write-Host "Would you like to collect multiple memory dumps (2 or more)?" -ForegroundColor Yellow

# validate Y/N input
while ($true)
{
    $YesNo = Read-Host "Enter Y or N>"

    if ($YesNo -in "y","n")
    {
        break
    }
    Write-Host "Not a valid 'Y' or 'N' response"
}

# get input on how many dumps and at what interval
if ($YesNo -eq "y")
{
    [int]$DumpCountInt=0
    while (1 -ge $DumpCountInt)
    {
        Write-Host "How many dumps would you like to generate for this $ProductStr ?" -ForegroundColor Yellow
        $DumpCountStr = Read-Host ">"

        if ([int]::TryParse($DumpCountStr, [ref]$DumpCountInt) -and $DumpCountInt -gt 1)
        {
            break
        }
        Write-Host "Please enter a number greater than one." -ForegroundColor Red
    }

    [int]$DelayIntervalInt=0
    while ($true)
    {
        Write-Host "How frequently (in seconds) would you like to generate the memory dumps?" -ForegroundColor Yellow
        $DelayIntervalStr = Read-Host ">"

        if ([int]::TryParse($DelayIntervalStr, [ref]$DelayIntervalInt) -and $DelayIntervalInt -gt 0)
        {
            break
        }
        Write-Host "Please enter a number greater than zero." -ForegroundColor Red
    }

    Write-Host "Generating $DumpCountInt memory dumps at a $DelayIntervalStr-second interval" -ForegroundColor Green

    # loop to generate multiple dumps
    $cntr = 0
    while ($true)
    {
        Start-Process -FilePath $cmd -Wait -Verb runAs -ArgumentList $arglist
        $cntr++

        Write-Host "Generated $cntr memory dump(s)." -ForegroundColor Green

        if ($cntr -ge $DumpCountInt)
        {
            break
        }
        Start-Sleep -S $DelayIntervalInt
    }

    # print what files exist in the output folder
    Write-Host ""
    Write-Host "Here are all the memory dumps in the output folder '$OutputFolder'" -ForegroundColor Green
    $MemoryDumps = $OutputFolder + "\SQLDmpr*"
    Get-ChildItem -Path $MemoryDumps

    Write-Host ""
    Write-Host "Process complete"
}
else # produce just a single dump
{
    Start-Process -FilePath $cmd -Wait -Verb runAs -ArgumentList $arglist

    # print what files exist in the output folder
    Write-Host ""
    Write-Host "Here are all the memory dumps in the output folder '$OutputFolder'" -ForegroundColor Green
    $MemoryDumps = $OutputFolder + "\SQLDmpr*"
    Get-ChildItem -Path $MemoryDumps

    Write-Host ""
    Write-Host "Process complete"
}

Write-Host "For errors and completion status, review SQLDUMPER_ERRORLOG.log created by SQLDumper.exe in the output folder '$OutputFolder'.`nOr if SQLDumper.exe failed, look in the folder from which you are running this script."

Exécutez-la à partir de l’invite de commandes en tant qu’administrateur à l’aide de la commande suivante :
```
Powershell.exe -File SQLDumpHelper.ps1
```
Ou exécutez-la à partir de la console Windows PowerShell et exécutez-la en tant qu’administrateur à l’aide de la commande suivante :
```
.\SQLDumpHelper.ps1
```

Note

Si vous n’avez jamais exécuté de scripts PowerShell sur votre système, vous pouvez recevoir le message d’erreur suivant :

"Fichier ... SQLDumpHelper.ps1 ne peut pas être chargé, car l’exécution de scripts est désactivée sur ce système. »

Pour permettre l’exécution des commandes, procédez comme suit :

Démarrez la console Windows PowerShell à l’aide de l’option Exécuter en tant qu’administrateur . Seuls les membres du groupe Administrateurs sur l’ordinateur peuvent modifier la stratégie d’exécution.
Activez l’exécution de scripts non signés par la commande suivante :
```
Set-ExecutionPolicy RemoteSigned
```
Note

Cela vous permet d’exécuter des scripts non signés que vous créez sur votre ordinateur local et des scripts signés à partir d’Internet.

Partager via

Utiliser l’outil Sqldumper.exe pour générer un fichier de vidage dans SQL Server

Résumé

Comment exécuter Sqldumper.exe manuellement

Comment obtenir un identificateur de processus d’application Microsoft Windows

Chemin d’accès de sortie pour les fichiers de vidage de mémoire

Comment modifier le chemin d’accès par défaut

Spécifier un dossier de sortie personnalisé dans la commande

Spécifications relatives aux autorisations

Impact de la génération de vidage

Gérer l’impact sur les systèmes en cluster

Améliorations apportées aux produits pour réduire l’impact sur SQL Server

Mécanisme de filtrage bitmap

Élimination des vidages répétés sur le même problème

Sortie raccourcie dans le journal des erreurs

Compression parallèle des vidages de mémoire

Facteurs qui empêchent ou retardent la création de vidages de mémoire

Types de vidage

Mini dumps avec mémoire référencée

Vidages complets

Vidages filtrés

Générer un vidage de mémoire sur les basculements de cluster

Configuration du cluster pour SQLDumper sur SQL Server 2012 et versions ultérieures

Configuration du cluster pour SQLDumper sur SQL Server 2008/2008 R2 ou Windows 2012 et versions antérieures

Supprimer les propriétés de Sqldumper.exe pour le basculement de cluster

Utilisation de DBCC STACKDUMP

Fonctionnalité DBCC STACKDUMP étendue introduite dans SQL Server 2019

Comment utiliser un script PowerShell pour générer un fichier de vidage avec SQLDumper

Commentaires

Ressources supplémentaires