Database
 sql >> Datenbank >  >> RDS >> Database

Automatisches E-Mail-System zum Senden des Datenbankzusammenfassungsberichts

Die Datenbanküberwachung ist die wichtigste Aufgabe eines jeden Datenbankadministrators. Große Organisationen und Unternehmen haben mehrere Datenbankserver, die sich entweder im selben Rechenzentrum oder in geografisch unterschiedlichen Rechenzentren befinden. Es gibt viele Standardtools für die Datenbanküberwachung. Diese Tools verwenden die dynamischen Verwaltungsansichten von SQL Server und die gespeicherte Systemprozedur, um die Daten aufzufüllen. Mithilfe dieser DMVs können wir unser angepasstes automatisiertes System erstellen, um den Status der Datenbank aufzufüllen und den Bericht per E-Mail zu versenden.

In diesem Artikel werde ich demonstrieren, wie wir die gespeicherte Systemprozedur und den verknüpften Server verwenden können, um die Informationen von Datenbanken zu füllen, die sich auf verschiedenen Servern befinden, und den Job zum Senden des Berichts zu planen.

In dieser Demo werde ich die folgenden Aufgaben ausführen:

  1. Erstellen Sie erforderliche gespeicherte Prozeduren auf TTI609-VM1 , TTI609-VM2, und TTI412-VM Server, um Informationen der Datenbank, Datenbankobjekte und SQL-Jobs aufzufüllen.
  2. Erstellen Sie eine gespeicherte Prozedur, um die Datenbankzusammenfassung, die Datenbankobjektzusammenfassung und die SQL-Jobzusammenfassung aus dem TTI609-VM1 zu füllen und TTI609-VM2 Server und speichern sie in zugehörigen Tabellen.
  3. Erstellen Sie ein SSIS-Paket, das die folgenden Aufgaben ausführt:
      • Führt eine gespeicherte Prozedur mit der Aufgabe SQL-Skript ausführen aus .
      • Exportieren Sie Daten aus SQL-Tabellen, die auf TTI412-VM erstellt wurden und speichern Sie es in der individuellen Registerkarte einer Excel-Datei.
  4. Erstellen Sie einen SQL Server-Job, um das SSIS-Paket auszuführen, um die Datenbankinformationen und die gespeicherte Prozedur zum Versenden des Berichts per E-Mail aufzufüllen.

Das folgende Bild zeigt das Demo-Setup:

Es folgt die Liste der gespeicherten Prozeduren:

Es folgt die Liste der Tabellen:

Gespeicherte Prozeduren auf beiden Datenbankservern erstellen

Wie ich bereits erwähnt habe, werden wir Daten aus dem TTI609-VM1 auffüllen und TTI609-VM2 Server. Die zum Füllen der Datenbank verwendeten gespeicherten Prozeduren bleiben auf beiden Servern gleich.
Zuerst habe ich also eine Datenbank mit dem Namen DBATools erstellt auf beiden Servern. Ich habe eine gespeicherte Prozedur in diesen Datenbanken erstellt. Führen Sie dazu den folgenden Code auf dem TTI609-VM1 aus und TTI609-VM2 Server:

USE [master] 
go 
/****** Object:  Database [DBATools]    Script Date: 10/25/2018 11:25:27 AM ******/ 
CREATE DATABASE [DBATools] containment = none ON PRIMARY ( NAME = N'DBATools', 
filename = 
N'C:\Program Files\Microsoft SQL Server\MSSQL12.MSSQLSERVER\MSSQL\DATA\DBATools.mdf' 
, size = 3264kb, maxsize = unlimited, filegrowth = 1024kb ) log ON ( NAME = 
N'DBATools_log', filename = 
N'C:\Program Files\Microsoft SQL Server\MSSQL12.MSSQLSERVER\MSSQL\DATA\DBATools_log.ldf' 
, size = 816kb, maxsize = 2048gb, filegrowth = 10%) 
go

Erstellen Sie eine gespeicherte Prozedur namens Pull_Database_Information in den DBATools Datenbank. Diese gespeicherte Prozedur füllt die folgenden Informationen aller Datenbanken, die auf beiden Datenbankservern vorhanden sind.

  1. Datenbankname.
  2. Datenbankkompatibilitätsstufe.
  3. Status der Datenbank (ONLINE/OFFLINE/WIEDERHERSTELLEN/SPERREN).
  4. Datenbankwiederherstellungsmodell (EINFACH / VOLLSTÄNDIG / BULK-LOGGED).
  5. Datenbankgröße in MB.
  6. Gesamtgröße der Datendatei.
  7. Größe der verwendeten Datendatei.
  8. Gesamtgröße der Protokolldatei.
  9. Verwendete Protokolldateigröße.

Führen Sie den folgenden Code in den DBATools aus Datenbank beider Datenbankserver, um die gespeicherte Prozedur zu erstellen:

USE DBAtools 
go 
CREATE PROCEDURE Pull_Database_Information 
AS 
  BEGIN 
      IF Object_id('tempdb.dbo.#DBSize') IS NOT NULL 
        DROP TABLE #dbsize 

      CREATE TABLE #dbsize 
        ( 
           database_id         INT PRIMARY KEY, 
           data_file_used_size DECIMAL(18, 2), 
           log_file_used_size  DECIMAL(18, 2) 
        ) 

      DECLARE @SQLCommand NVARCHAR(max) 

      SELECT @SQLCommand = Stuff((SELECT '     USE [' + d.NAME + ']     INSERT INTO #DBSize (database_id, data_file_used_size, log_File_used_size)     SELECT           DB_ID()         , SUM(CASE WHEN [type] = 0 THEN space_used END)         , SUM(CASE WHEN [type] = 1 THEN space_used END)     FROM (         SELECT s.[type], space_used = SUM(FILEPROPERTY(s.name, ''SpaceUsed'') * 8. / 1024)         FROM sys.database_files s         GROUP BY s.[type]     ) t;' 
                                  FROM   sys.databases d 
                                  WHERE  d.[state] = 0 
                                  FOR xml path(''), type).value('.', 
                           'NVARCHAR(MAX)'), 
                           1, 2, 
                                  '') 

      EXEC sys.Sp_executesql 
        @SQLCommand 

      SELECT d.database_id         AS 'Database ID', 
             d.NAME                AS 'Database Name', 
             d.state_desc          AS 'Database State', 
             d.recovery_model_desc AS 'Recovery Model', 
             t.total_db_size       AS 'Database Size', 
             t.data_file_size      AS 'Data File Size', 
             s.data_file_used_size AS 'Data File Used', 
             t.log_file_size       AS 'Log file size', 
             s.log_file_used_size  AS 'Log File Used' 
      FROM   (SELECT database_id, 
                     log_file_size = Cast(Sum(CASE 
                                                WHEN [type] = 1 THEN size 
                                              END) * 8. / 1024 AS DECIMAL(18, 2) 
                                     ), 
                     data_file_size = Cast(Sum(CASE 
                                                 WHEN [type] = 0 THEN size 
                                               END) * 8. / 1024 AS 
                                           DECIMAL(18, 2)) 
                     , 
                     total_DB_size = Cast( 
                     Sum(size) * 8. / 1024 AS DECIMAL(18, 2)) 
              FROM   sys.master_files 
              GROUP  BY database_id) t 
             JOIN sys.databases d 
               ON d.database_id = t.database_id 
             LEFT JOIN #dbsize s 
                    ON d.database_id = s.database_id 
      ORDER  BY t.total_db_size DESC 
  END

Erstellen Sie zweitens gespeicherte Prozeduren mit dem Namen Pull_Database_Objects in den DBATools Datenbank. Diese gespeicherte Prozedur durchläuft alle Datenbanken auf beiden Datenbankservern und füllt die Anzahl aller Datenbankobjekte. Es füllt die folgenden Spalten:

  1. Server-/Hostname.
  2. Datenbankname.
  3. Typ des Datenbankobjekts (Tabelle / Stored Procedure / SQL Scaler-Funktionen / Constraints etc…)
  4. Gesamtzahl der Datenbankobjekte.

Führen Sie den folgenden Code in den DBATools aus Datenbank auf beiden Datenbankservern, um die gespeicherte Prozedur zu erstellen:

USE dbatools 
go 

CREATE PROCEDURE [Pull_database_objects] 
AS 
  BEGIN 
      CREATE TABLE #finalsummery 
        ( 
           id           INT IDENTITY (1, 1), 
           databasename VARCHAR(350), 
           objecttype   VARCHAR(200), 
           totalobjects INT 
        ) 

      DECLARE @SQLCommand NVARCHAR(max) 
      DECLARE @I INT=0 
      DECLARE @DBName VARCHAR(350) 
      DECLARE @DBCount INT 

      CREATE TABLE #databases 
        ( 
           NAME VARCHAR(350) 
        ) 

      INSERT INTO #databases 
                  (NAME) 
      SELECT NAME 
      FROM   sys.databases 
      WHERE  database_id > 4 
             AND NAME NOT IN ( 'ReportServer', 'reportservertempdb' ) 

      SET @DBCount=(SELECT Count(*) 
                    FROM   #databases) 

      WHILE ( @DBCount > @I ) 
        BEGIN 
            SET @DBName=(SELECT TOP 1 NAME 
                         FROM   #databases) 
            SET @SQLCommand='             Insert Into #FinalSummery (DatabaseName,ObjectType,TotalObjects)             Select              ''' + @DBName 
                            + ''',             Case                 when Type=''TR'' then ''SQL DML trigger''              when Type=''FN'' then ''SQL scalar function''              when Type=''D'' then ''DEFAULT (constraint or stand-alone)''              when Type=''PK'' then ''PRIMARY KEY constraint''              when Type=''P'' then ''SQL Stored Procedure''              when Type=''U'' then ''Table (user-defined)''              when Type=''V''  then ''View''              when Type=''X'' then ''Extended stored procedure''             End As ObjectType,              Count(Name)TotalObjects from ' + @DBName 
                            + '.sys.all_objects               group by type' 

            EXEC Sp_executesql 
              @SQLCommand 

            DELETE FROM #databases 
            WHERE  NAME = @DBName 

            SET @[email protected] + 1 
        END 

      SELECT Host_name() AS 'Server Name', 
             databasename, 
             objecttype, 
             totalobjects, 
             Getdate()   AS 'ReportDate' 
      FROM   #finalsummery 
      WHERE  objecttype IS NOT NULL 

      DROP TABLE #finalsummery 
  END

Erstellen Sie gespeicherte Prozeduren mit dem Namen Pull_SQLJob_Information in den DBATools Datenbank. Diese gespeicherte Prozedur durchläuft alle Datenbankserver und füllt die Informationen aller SQL-Jobs und deren Status. Es füllt die folgenden Spalten:

  1. Server-/Hostname.
  2. SQL-Auftragsname.
  3. Eigentümer des SQL-Jobs.
  4. Jobkategorie.
  5. Beschreibung der Stelle.
  6. Jobstatus (Aktiviert / Deaktiviert)
  7. Ein Datum der Schaffung von Arbeitsplätzen.
  8. Änderungsdatum des Jobs.
  9. Geplanter Auftragsstatus.
  10. Zeitplanname.
  11. Datum und Uhrzeit der letzten Ausführung
  12. Letzter Ausführungsstatus.

Führen Sie den folgenden Code in den DBATools aus Datenbank auf beiden Datenbankservern, um die gespeicherte Prozedur zu erstellen:

CREATE PROCEDURE Pull_sqljob_information 
AS 
  BEGIN 
      SELECT Host_name()       AS 'Server Name', 
             a.NAME            AS 'Job Name', 
             d.NAME            AS Owner, 
             b.NAME            AS Category, 
             a.description     AS Description, 
             CASE a.enabled 
               WHEN 1 THEN 'Yes' 
               WHEN 0 THEN 'No' 
             END               AS 'IsEnabled', 
             a.date_created    AS CreatedDate, 
             a.date_modified   AS ModifiedDate, 
             CASE 
               WHEN f.schedule_uid IS NULL THEN 'No' 
               ELSE 'Yes' 
             END               AS 'Scheduled?', 
             f.NAME            AS JobScheduleName, 
             Max(Cast( 
      Stuff(Stuff(Cast(g.run_date AS VARCHAR), 7, 0, '-'), 5, 0, '-') 
           + ' ' 
           + 
Stuff(Stuff(Replace(Str(g.run_time, 6, 0), ' ', '0'), 5, 0, ':'), 3, 0, ':') 
AS DATETIME)) AS [LastRun], 
CASE g.run_status 
WHEN 0 THEN 'Failed' 
WHEN 1 THEN 'Success' 
WHEN 2 THEN 'Retry' 
WHEN 3 THEN 'Canceled' 
WHEN 4 THEN 'In progress' 
END               AS Status 
FROM   msdb.dbo.sysjobs AS a 
       INNER JOIN msdb.dbo.sysjobhistory g 
               ON a.job_id = g.job_id 
       LEFT JOIN msdb.dbo.syscategories AS b 
              ON a.category_id = b.category_id 
       LEFT JOIN msdb.dbo.sysjobsteps AS c 
              ON a.job_id = c.job_id 
                 AND a.start_step_id = c.step_id 
       LEFT JOIN msdb.sys.database_principals AS d 
              ON a.owner_sid = d.sid 
       LEFT JOIN msdb.dbo.sysjobschedules AS e 
              ON a.job_id = e.job_id 
       LEFT JOIN msdb.dbo.sysschedules AS f 
              ON e.schedule_id = f.schedule_id 
GROUP  BY a.NAME, 
          d.NAME, 
          b.NAME, 
          a.description, 
          a.enabled, 
          f.schedule_uid, 
          f.NAME, 
          a.date_created, 
          a.date_modified, 
          g.run_status 
ORDER  BY a.NAME 
END

Erstellen Sie Stored Procedures, Linked Server und Tabellen auf dem zentralen Server

Nachdem die Prozeduren auf dem TTI609-VM1 erstellt wurden und TTI609-VM2 Datenbankserver, erstellen Sie erforderliche Prozeduren und Tabellen auf dem zentralen Server (TTI412-VM ).

Ich habe eine separate Datenbank namens MonitoringDashboard erstellt auf der TTI412-VM Server. Führen Sie den folgenden Code aus, um eine Datenbank auf dem zentralen Server zu erstellen.

USE [master] 
go 

/****** Object:  Database [MonitoringDashboard]    Script Date: 10/25/2018 2:44:09 PM ******/ 

CREATE DATABASE [MonitoringDashboard] containment = none ON PRIMARY ( NAME = 
N'MonitoringDashboard', filename = 
N'E:\MS_SQL\SQL2017_Data\MonitoringDashboard.mdf', size = 8192kb, maxsize = 
unlimited, filegrowth = 65536kb ) log ON ( NAME = N'MonitoringDashboard_log', 
filename = N'E:\MS_SQL\SQL2017_Log\MonitoringDashboard_log.ldf', size = 8192kb, 
maxsize = 2048gb, filegrowth = 65536kb ) 

go

Nachdem die Datenbank erstellt wurde, erstellen Sie eine gespeicherte Prozedur, die LINKED Server verwendet, um eine Prozedur auf dem TTI609-VM1 auszuführen und TTI609-VM2 Datenbankserver. Führen Sie den folgenden Code in der „master“-Datenbank der TTI412-VM aus Datenbankserver, um einen Verbindungsserver zu erstellen:

Skript 1:Verbindungsserver TTI609-VM1 erstellen

USE [master] 
go 
/****** Object:  LinkedServer [TTI609-VM1]    Script Date: 10/25/2018 2:49:28 PM ******/ 
EXEC master.dbo.Sp_addlinkedserver 
  @server = N'TTI609-VM1', 
  @srvproduct=N'SQL Server' 

/* For security reasons the linked server remote logins password is changed with ######## */ 
EXEC master.dbo.Sp_addlinkedsrvlogin 
  @rmtsrvname=N'TTI609-VM1', 
  @useself=N'False', 
  @locallogin=NULL, 
  @rmtuser=N'sa', 
  @rmtpassword='########' 

go 

EXEC master.dbo.Sp_serveroption 
  @server=N'TTI609-VM1', 
  @optname=N'collation compatible', 
  @optvalue=N'true' 

go 

EXEC master.dbo.Sp_serveroption 
  @server=N'TTI609-VM1', 
  @optname=N'data access', 
  @optvalue=N'true' 

go 

EXEC master.dbo.Sp_serveroption 
  @server=N'TTI609-VM1', 
  @optname=N'dist', 
  @optvalue=N'false' 

go 

EXEC master.dbo.Sp_serveroption 
  @server=N'TTI609-VM1', 
  @optname=N'rpc', 
  @optvalue=N'true' 

go 

EXEC master.dbo.Sp_serveroption 
  @server=N'TTI609-VM1', 
  @optname=N'rpc out', 
  @optvalue=N'true' 

go 

EXEC master.dbo.Sp_serveroption 
  @server=N'TTI609-VM1', 
  @optname=N'connect timeout', 
  @optvalue=N'0' 

go 

EXEC master.dbo.Sp_serveroption 
  @server=N'TTI609-VM1', 
  @optname=N'query timeout', 
  @optvalue=N'0' 

go 

EXEC master.dbo.Sp_serveroption 
  @server=N'TTI609-VM1', 
  @optname=N'use remote collation', 
  @optvalue=N'true' 

go 

EXEC master.dbo.Sp_serveroption 
  @server=N'TTI609-VM1', 
  @optname=N'remote proc transaction promotion', 
  @optvalue=N'false' 

go

Skript 2:Verbindungsserver TTI609-VM2 erstellen

USE [master] 

go 

/****** Object:  LinkedServer [TTI609-VM2]    Script Date: 10/25/2018 2:55:29 PM ******/ 
EXEC master.dbo.Sp_addlinkedserver 
  @server = N'TTI609-VM2', 
  @srvproduct=N'SQL Server' 

/* For security reasons the linked server remote logins password is changed with ######## */ 
EXEC master.dbo.Sp_addlinkedsrvlogin 
  @rmtsrvname=N'TTI609-VM2', 
  @useself=N'False', 
  @locallogin=NULL, 
  @rmtuser=N'sa', 
  @rmtpassword='########' 

go 

EXEC master.dbo.Sp_serveroption 
  @server=N'TTI609-VM2', 
  @optname=N'collation compatible', 
  @optvalue=N'true' 

go 

EXEC master.dbo.Sp_serveroption 
  @server=N'TTI609-VM2', 
  @optname=N'data access', 
  @optvalue=N'true' 

go 

EXEC master.dbo.Sp_serveroption 
  @server=N'TTI609-VM2', 
  @optname=N'dist', 
  @optvalue=N'false' 

go 

EXEC master.dbo.Sp_serveroption 
  @server=N'TTI609-VM2', 
  @optname=N'rpc', 
  @optvalue=N'true' 

go 

EXEC master.dbo.Sp_serveroption 
  @server=N'TTI609-VM2', 
  @optname=N'rpc out', 
  @optvalue=N'true' 

go 

EXEC master.dbo.Sp_serveroption 
  @server=N'TTI609-VM2', 
  @optname=N'connect timeout', 
  @optvalue=N'0' 

go 

EXEC master.dbo.Sp_serveroption 
  @server=N'TTI609-VM2', 
  @optname=N'collation name', 
  @optvalue=NULL 

go 

EXEC master.dbo.Sp_serveroption 
  @server=N'TTI609-VM2', 
  @optname=N'query timeout', 
  @optvalue=N'0' 

go 

EXEC master.dbo.Sp_serveroption 
  @server=N'TTI609-VM2', 
  @optname=N'use remote collation', 
  @optvalue=N'true' 

go 

EXEC master.dbo.Sp_serveroption 
  @server=N'TTI609-VM2', 
  @optname=N'remote proc transaction promotion', 
  @optvalue=N'false' 

go

Erstellen Sie eine gespeicherte Prozedur und Tabellen

Nachdem der Verbindungsserver erstellt wurde, müssen wir drei Tabellen namens Database_Object_Summery erstellen , Database_Summery undSQL_Job_List im MonitoringDashboard Datenbank. Diese Tabellen speichern Informationen, die von Generate_Database_Information ausgefüllt werden gespeicherte Prozedur und später die Daten, die in diesen Tabellen gespeichert sind, die zum Generieren eines Berichts in Excel verwendet werden.

Führen Sie den folgenden Code aus, um die SQL_Job_List zu erstellen Tabelle:

USE [MonitoringDashboard] 
go 

CREATE TABLE [dbo].[sql_job_list] 
  ( 
     [id]             [INT] IDENTITY(1, 1) NOT NULL, 
     [servername]     [VARCHAR](250) NULL, 
     [jobname]        [VARCHAR](250) NULL, 
     [jobowner]       [VARCHAR](250) NULL, 
     [jobcategory]    [VARCHAR](250) NULL, 
     [jobdescription] [VARCHAR](250) NULL, 
     [jobstatus]      [VARCHAR](50) NULL, 
     [createdate]     [DATETIME] NULL, 
     [modifieddate]   [DATETIME] NULL, 
     [isscheduled]    [VARCHAR](5) NULL, 
     [schedulename]   [VARCHAR](250) NULL, 
     [reportdate]     [DATETIME] NULL 
  ) 
ON [PRIMARY] 

go 

ALTER TABLE [dbo].[sql_job_list] 
  ADD DEFAULT (Getdate()) FOR [ReportDate] 

go

Führen Sie den folgenden Code aus, um die lst_dbservers zu erstellen Tabelle:

USE [MonitoringDashboard] 

go 

CREATE TABLE [dbo].[lst_dbservers] 
  ( 
     [id]         [INT] IDENTITY(1, 1) NOT NULL, 
     [servername] [VARCHAR](50) NOT NULL, 
     [addeddate]  [DATETIME] NOT NULL, 
     PRIMARY KEY CLUSTERED ( [id] ASC )WITH (pad_index = OFF, 
     statistics_norecompute = OFF, ignore_dup_key = OFF, allow_row_locks = on, 
     allow_page_locks = on) ON [PRIMARY], 
     UNIQUE NONCLUSTERED ( [servername] ASC )WITH (pad_index = OFF, 
     statistics_norecompute = OFF, ignore_dup_key = OFF, allow_row_locks = on, 
     allow_page_locks = on) ON [PRIMARY] 
  ) 
ON [PRIMARY] 

go 

ALTER TABLE [dbo].[lst_dbservers] 
  ADD DEFAULT (Getdate()) FOR [AddedDate] 

go

Führen Sie den folgenden Code aus, um Database_Summery zu erstellen Tabelle:

USE [MonitoringDashboard] 
go 
CREATE TABLE [dbo].[database_summery] 
  ( 
     [id]                 [INT] IDENTITY(1, 1) NOT NULL, 
     [servername]         [VARCHAR](150) NULL, 
     [databaseid]         [INT] NULL, 
     [databasename]       [VARCHAR](250) NULL, 
     [databasestatus]     [VARCHAR](50) NULL, 
     [recoverymodel]      [VARCHAR](50) NULL, 
     [compatibilitylevel] [INT] NULL, 
     [databasecreatedate] [DATE] NULL, 
     [databasecreatedby]  [VARCHAR](150) NULL, 
     [dbsize]             [NUMERIC](10, 2) NULL, 
     [datafilesize]       [NUMERIC](10, 2) NULL, 
     [datafileused]       [NUMERIC](10, 2) NULL, 
     [logfilesize]        [NUMERIC](10, 2) NULL, 
     [logfileused]        [NUMERIC](10, 2) NULL, 
     [reportdate]         [DATETIME] NULL 
  ) 
ON [PRIMARY] 
go 

ALTER TABLE [dbo].[database_summery] 
  ADD DEFAULT (Getdate()) FOR [ReportDate] 
go

Führen Sie den folgenden Code aus, um Database_Object_Summery zu erstellen Tabelle:

USE [MonitoringDashboard] 

go 

CREATE TABLE [dbo].[database_object_summery] 
  ( 
     [id]           [INT] IDENTITY(1, 1) NOT NULL, 
     [servername]   [VARCHAR](250) NULL, 
     [databasename] [VARCHAR](250) NULL, 
     [objecttype]   [VARCHAR](50) NULL, 
     [objectcount]  [INT] NULL, 
     [reportdate]   [DATETIME] NULL 
  ) 
ON [PRIMARY] 

go 

ALTER TABLE [dbo].[database_object_summery] 
  ADD DEFAULT (Getdate()) FOR [ReportDate] 

go

Sobald die Tabellen erstellt sind, erstellen Sie eine gespeicherte Prozedur mit dem Namen Generate_Database_Information auf dem MonitoringDashboard Datenbank. Unter Verwendung von „RPC“ führt es gespeicherte Prozeduren aus, die auf dem TTI609-VM1 erstellt wurden und TTI609-VM2 Datenbankserver, um die Daten zu füllen.

Führen Sie den folgenden Code aus, um eine gespeicherte Prozedur zu erstellen:

Create PROCEDURE Generate_database_information 
AS 
  BEGIN 
      /*Cleanup*/ 
      TRUNCATE TABLE database_object_summery 
      TRUNCATE TABLE database_summery 
      TRUNCATE TABLE sql_job_list 

      DECLARE @ServerCount INT 
      DECLARE @i INT =0 
      DECLARE @SQLCommand_Object_Summery NVARCHAR(max) 
      DECLARE @SQLCommand_Database_Information NVARCHAR(max) 
      DECLARE @SQLCommand_SQL_Job_Information NVARCHAR(max) 
      DECLARE @servername VARCHAR(100) 

      CREATE TABLE #db_server_list 
        ( 
           servername VARCHAR(100) 
        ) 

      INSERT INTO #db_server_list 
                  (servername) 
      SELECT servername 
      FROM   lst_dbservers 

      SET @ServerCount= (SELECT Count(servername) 
                         FROM   #db_server_list) 

      WHILE ( @ServerCount > @i ) 
        BEGIN 
            SET @servername=(SELECT TOP 1 servername 
                             FROM   #db_server_list) 
            SET @SQLCommand_Object_Summery = 
'insert into Database_Object_Summery (ServerName,DatabaseName,ObjectType,ObjectCount,ReportDate) exec [' 
+ @servername 
+ '].DBATools.dbo.[Pull_Database_Objects]' 
    SET @SQLCommand_Database_Information = 
'insert into Database_Summery (ServerName,DatabaseID,DatabaseName,DatabaseStatus,Recoverymodel,CompatibilityLevel,DatabaseCreateDate,DatabaseCreatedBy,DBSize,DataFileSize,DataFileUsed,LogFileSize,LogFileUsed) exec [' 
+ @servername 
+ '].DBATools.dbo.[Pull_Database_Information]' 
    SET @SQLCommand_SQL_Job_Information = 
'insert into SQL_Job_List (ServerName,JobName,JobOwner,Jobcategory,JobDescription,JobStatus,CreateDate,ModifiedDate,IsScheduled,ScheduleName) exec [' 
+ @servername 
+ '].DBATools.dbo.[Pull_SQLJob_Information]' 

    EXEC Sp_executesql 
      @SQLCommand_Object_Summery 

    EXEC Sp_executesql 
      @SQLCommand_Database_Information 

    EXEC Sp_executesql 
      @SQLCommand_SQL_Job_Information 

    DELETE FROM #db_server_list 
    WHERE  servername = @servername 

    SET @[email protected] + 1 
END 
END

Sobald die Prozedur erstellt ist, erstellen Sie ein SSIS-Paket, um Daten in eine Excel-Datei zu exportieren.

SSIS-Paket erstellen, um Daten in eine Excel-Datei zu exportieren

In meinen früheren Artikeln habe ich die Schritte zum Konfigurieren der Datenflussaufgaben, OLEDB-Verbindungen und Excel-Verbindungen erklärt, daher überspringe ich diesen Teil.

Um Daten in eine Excel-Datei zu exportieren, öffnen Sie die SQL Server-Datentools und erstellen Sie ein neues SSIS-Projekt mit dem Namen Export_Database_Information.

Sobald das Projekt erstellt ist, ziehen Sie SQL-Aufgabe ausführen per Drag-and-Drop zum Kontrollfluss Fenster und benennen Sie es in Daten von Servern auffüllen um . Siehe folgendes Bild:

Doppelklicken Sie auf SQL-Task ausführen (Daten vom Server auffüllen). Der SQL-Aufgaben-Editor Das Dialogfeld zum Konfigurieren der SQL-Verbindung wird geöffnet. Siehe folgendes Bild:

In der Verbindung abgelegt, wählen Sie die OLEDB aus Verbindungszeichenfolge und in der SQL-Anweisung Geben Sie im Feld folgende Abfrage ein:

USE monitoringdashboard 
go 
EXEC Generate_database_information

Klicken Sie auf OK, um das Dialogfeld zu schließen.

Auf dem Kontrollfluss Ziehen Sie die Datenflussaufgabe aus der SSIS-Toolbox und benennen Sie sie in Bericht erstellen. um Siehe folgendes Bild:

Doppelklicken Sie, um den Datenfluss zu öffnen Fenster.

Wie ich bereits erwähnt habe, ist die Generate_Database_Information Die Prozedur fügt die Ausgabe der Datenbankserver in die folgenden Tabellen ein:

  1. Database_Object_Summery
  2. Database_Summery
  3. SQL_Job_List

Ich habe eine Excel-Datei mit drei Arbeitsblättern erstellt. Die folgenden Tabellen zeigen die Zuordnung der SQL-Tabellen und des Excel-Arbeitsblatts.


Im Datenfluss Ziehen Sie im Fenster drei ADO.Net-Quellen und drei Excel-Ziele und legen Sie sie dort ab. Siehe folgendes Bild:

Doppelklicken Sie auf Objektzusammenfassung y (ADO.NET-Quelle) in ADO.NET-Quelle Herausgeber.

  1. Wählen Sie TTI412-VM\SQL2017MonitoringDashboard aus aus dem ADO.NET Connection Manager Dropdown-Feld.
  2. Wählen Sie Tabelle oder Ansicht aus dem Datenzugriffsmodus Dropdown-Feld.
  3. Wählen Sie Database_Object_Summery aus aus Name der Tabelle oder Ansicht Dropdown-Feld.

Doppelklicken Sie auf Datenbankinformationen (ADO.NET Source) im ADO.NET Source Editor .

  1. Wählen Sie „TTI412-VM\SQL2017MonitoringDashboard aus ” aus dem ADO.NET Connection Manager Dropdown-Feld.
  2. Wählen Sie Tabelle oder Ansicht aus dem Datenzugriffsmodus Dropdown-Feld.
  3. Wählen Sie „Database_Summery aus ” aus dem Namen der Tabelle oder der Ansicht Dropdown-Feld.

Doppelklicken Sie auf SQL-Jobs (ADO.NET Source) im ADO.NET Source Editor .

  1. Wählen Sie TTI412-VM\SQL2017MonitoringDashboard aus im ADO.NET Connection Manager.
  2. Wählen Sie Tabelle oder Ansicht aus dem Datenzugriffsmodus Dropdown-Feld.
  3. Wählen Sie SQL_Job_List aus im Namen der Tabelle oder der Ansicht Dropdown-Feld.

Ziehen Sie nun drei Excel-Ziele per Drag &Drop aus der SSIS-Toolbox. Siehe folgendes Bild:

Nachdem die Ziele kopiert wurden, ziehen Sie den blauen Pfeil unter die ADO.Net-Quelle und legen Sie ihn auf dem Excel-Ziel ab. Machen Sie dasselbe für alle. Siehe folgendes Bild:

Doppelklicken Sie auf Excel-Objektzusammenfassung (ADO.NET-Quelle) im Excel-Ziel-Editor .

  1. Wählen Sie Excel Connection Manager aus aus dem Excel Connection Manager Dropdown-Feld.
  2. Wählen Sie Tabellieren oder Anzeigen aus dem Datenzugriffsmodus Dropdown-Feld.
  3. Wählen Sie Objekt Summery$ aus demNamen der Excel-Tabelle Dropdown-Feld.

Wie ich bereits erwähnt habe, sind die Spaltennamen der SQL-Tabelle und der Excel-Spalten gleich, daher erfolgt die Zuordnung automatisch. Klicken Sie auf Zuordnung um die Spalten zuzuordnen. Siehe folgendes Bild:

Doppelklicken Sie auf Excel-Datenbankinformationen (Excel-Ziel) im Excel-Ziel-Editor .

  1. Wählen Sie Excel Connection Manager aus aus dem Excel Connection Manager Dropdown-Feld.
  2. Wählen Sie Tabellieren oder Anzeigen aus dem Datenzugriffsmodus Dropdown-Feld.
  3. Wählen Sie Datenbankinformationen$ aus aus demNamen der Excel-Tabelle Dropdown-Feld.

Wie ich bereits erwähnt habe, sind die Spaltennamen der SQL-Tabelle und der Excel-Spalten gleich, daher erfolgt die Zuordnung automatisch. Klicken Sie auf Zuordnung um die Spalten zuzuordnen. Siehe folgendes Bild:

Doppelklicken Sie auf Excel SQL-Jobs (Excel-Ziel) im Excel-Ziel-Editor .

  1. Wählen Sie Excel Connection Manager aus aus dem Excel Connection Manager Dropdown-Feld.
  2. Wählen Sie Tabellieren oder Anzeigen aus dem Datenzugriffsmodus Dropdown-Feld.
  3. Wählen Sie „SQL-Jobs$“ aus dem Namen der Excel-Tabelle aus Dropdown-Feld.

Wie ich bereits erwähnt habe, sind die Spaltennamen der SQL-Tabelle und der Excel-Spalten gleich, daher erfolgt die Zuordnung automatisch. Klicken Sie auf Zuordnung um die Spalten zuzuordnen. Siehe folgendes Bild:

Erstellen Sie einen SQL-Job, um den Datenbankbericht per E-Mail zu versenden

Sobald das Paket erstellt ist, erstellen Sie einen SQL-Job, um die folgenden Aktivitäten auszuführen:

  1. Führen Sie das SSIS-Paket aus, um Daten von allen Servern zu füllen.
  2. Senden Sie den Datenbankbericht per E-Mail an das erforderliche Team.

In SQL Job müssen wir zwei Schritte erstellen. Im ersten Schritt wird das SSIS-Paket ausgeführt und im zweiten Schritt wird das Verfahren zum Senden einer E-Mail ausgeführt.

Um einen SQL-Job zu erstellen, öffnen Sie SSMS>> SQL Server Agent>> Klicken Sie mit der rechten Maustaste auf Neuer SQL-Job .

Om der neue Job wählen Sie den Schritt Option und klicken Sie auf Nein w. Im Neuer Job-Schritt Dialogfeld im Schritt Name Geben Sie im Textfeld den gewünschten Namen ein und wählen Sie Paket für SQL Server-Integrationsdienste aus aus dem Typ Dropdown-Feld. Geben Sie im Pakettext einen Speicherort des SSIS-Pakets an Kasten. Siehe folgendes Bild:

Klicken Sie auf OK, um Neuer Jobschritt zu schließen .

Erstellen Sie einen weiteren Auftragsschritt, der eine gespeicherte Prozedur ausführt, um den Bericht per E-Mail zu versenden. Es verwendet eine Systemprozedur, um eine E-Mail zu senden. Das SSIS-Paket kopiert die Datenbankinformationen an einen bestimmten Ort, geben Sie daher den vollständigen Pfad der Excel-Datei im Parameter @file_attachments von sp_send_dbmail an gespeicherte Prozedur.

Um die gespeicherte Prozedur zu erstellen, führen Sie den folgenden Code in den DBATools aus Datenbank des zentralen Servers:

CREATE PROCEDURE Send_database_report 
AS 
  BEGIN 
      DECLARE @ProfileName VARCHAR(150) 

      SET @ProfileName = (SELECT NAME 
                          FROM   msdb..sysmail_profile 
                          WHERE  profile_id = 7) 

      DECLARE @lsMessage NVARCHAR(max) 

      SET @lsMessage = '<p style="font-family:Arial; font-size:10pt">   Hello Support,   Please find attached database summery report.      ' + '</p>' 

      EXEC msdb.dbo.Sp_send_dbmail 
        @recipients='[email protected]', 
        @[email protected], 
        @subject='Database Summery Report', 
        @file_attachments= 
      'C:\Users\Administrator\Desktop\Database_Information.xlsx', 
        @copy_recipients='', 
        @blind_copy_recipients='', 
        @body_format='HTML', 
        @[email protected] 
  END

Once the procedure is created, add a new SQL Job Schritt. Click New . In the New Job Step dialog box, provide a Job Step name, and select Transact-SQL script (T-SQL) from the Type Dropdown-Feld. In the Command Text box, write the following code:

USE DBAtools 
Go 

EXEC Send_database_report

Siehe folgendes Bild:

Click OK to close the wizard. Now to configure Job Schedule , select Schedules on the New Job Fenster. Click New to add a schedule.

In the New Job Schedule dialog box, provide the desired name in the Name text box, choose frequency and time. Siehe folgendes Bild:

Close OK to close the New Job Schedule and in the New Job window, click on OK to close the dialog box.

Now, to test the SQL Job, right-click the Email Database Report SQL job and click Start Job at Step .

In the result of successful completion of the SQL Job, you will receive an email with the database report. Siehe folgendes Bild:

Zusammenfassung

In this article I have covered as follows:

  1. How to populate information of the databases located on remote DB server.
  2. Create an SSIS package to populate database information and export it to excel file
  3. Create a multi-step SQL job to generate the report by executing an SSIS package and email the report.