Ruggiero Lauria Microsoft Tech

SQL Server Script to move Database Files

2019-01-18T19:09:00.000+01:00

Please consider that the below script uses the xp_cmdshell to issue the files move commands to the underlying OS.

It isn't default enabled on SQL Server Instances.
Be sure to enable this feature before running the script.
You can do it issuing these commands:

EXEC sp_configure 'show advanced options', 1;
GO
-- To update the currently configured value for advanced options.
RECONFIGURE;
GO
-- To enable the feature.
EXEC sp_configure 'xp_cmdshell', 1;
GO
-- To update the currently configured value for this feature.
RECONFIGURE;
GO

This script accepts 2 parameters:
@Dbname - Data Base Name to move
@UseDFDir - Use the SQL Server Instance Defaults paths 0 = No, 1 = Yes

If you are not willing to use the defaults be sure to set the correct paths in the script after the header:

declare @new_data_file_path nvarchar(300) = LOWER('f\SQLDati')
declare @new_log_file_path nvarchar(300) = LOWER('l:\SQLLogs')

You can check/set the default DB paths in the SQL Server properties

The script creates the dbo.movedbfiles StorePorcedure you can use launch it like this:

exec dbo.movedbfiles 'logtest', 1

------------------------- Script Start ------------------------------

create PROCEDURE dbo.MoveDBFiles @DBname varchar(300), @UseDFDir int = 0

AS
set nocount on;
/*
Title: Move Database Files
Created: 18-01-2019
By: Ruggiero Lauria

Steps: 1,change file location, 2, take db offline, 3, copy files, 4,take database back online

Input: Change the values for the following variables
@Dbname - Data Base Name to move
@UseDFDir - Use the SQL Server Instance Defaults paths 0 = No, 1 = Yes

Example: exec dbo.MoveDBFiles 'Db1' , 1

Notes:
Ensure that paths are set correctly prior to running scripts
Ensure you have enabled the xp_cmdshell on your instance

The script is provided as it is and for free, use it at your own risk.
Feel free to modify and distribute it

Credits:
Thanks to Christopher Provolt for the initial script template I have used to create mine:
https://cprovolt.wordpress.com/2014/09/10/move-database-files-script/

*/

/* Set your desired Directory if you ar not using the SQL Server Instance Defaults paths @UseDFDir = 0 */
declare @new_data_file_path nvarchar(300) = LOWER('f\SQLDati')
declare @new_log_file_path nvarchar(300) = LOWER('l:\SQLLogs')

/* Temp Table to hold script messages */

declare @message table
(
msg_num int,
message_text nvarchar(300)
)

/*Check if the DB exists and is not a System Database */
if (select database_id from sys.databases where name= @dbname) < 5 or (select count(*) from sys.databases where name= @dbname) = 0

insert into @message values((select count(*) from @message) + 1, 'Please check you DB Name, consider this procedure does not process System Databases')

else
begin
insert into @message values((select count(*) from @message) + 1, 'Processing Database: ' + @DBname )

/* Load the Instance default paths settings */
if (@UseDFDir =1)
begin
set @new_data_file_path = (select left(cast(serverproperty('InstanceDefaultDataPath') as varchar(100)), len(cast(serverproperty('InstanceDefaultDataPath') as nvarchar(100)) ) -1))
set @new_log_file_path = (select left(cast(serverproperty('InstanceDefaultLogPath') as varchar(100)), len(cast(serverproperty('InstanceDefaultLogPath') as nvarchar(100)) ) -1))
end

/* Dynamic table to hold information on database files and their locations
we will use this data to create the required move scripts
*/

declare @info table
(
id int primary key identity,
database_id int,
dbname varchar (50),
virtual_file_name varchar(50),
type_desc varchar(10),
db_file_name varchar(50),
file_path varchar(300)
)

/* Dynamic table to hold all the scripting lines created.

Steps: 1,change file location, 2, take db offline, 3, copy files, 4,database online
*/

declare @scripts table
(
step int,
scriptText varchar(300),
commtype char(4)
)

/* Dynamic table to store the changes that are to be made.
This data can be pasted into an email to inform customer of the changes
*/

/* Variable Decleration Area */
declare @id int; --id is created on temp table to use in cursor for processing data
declare @old_file_location varchar(1000) --temporarily stores the old file location for comparisons
declare @tmpString varchar(1000) -- used to temporarily hold strings
declare @temp_dbname varchar(100) -- holds temp database name
declare @temp_virtual_file_name varchar(100) -- holds temp virtual file name
declare @temp_file_name varchar(100) -- holds temp file name
declare @temp_old_file_location varchar(1000) --holds old location of the file
declare @new_file_path varchar(1000) --holds new location of the file
declare @num int = 0 -- Internal row counter
declare @numrows int -- Total number of files to move for the specified DB
declare @command nvarchar(1000) -- used to temporarily hold command to launch
declare @commtype char(4) -- used to temporarily hold command type to launch

/* get required data and place into @info dynamic table */
insert into @info
select mf.database_id,
db.name as 'dbname',
mf.name as 'virtual_file_name',
mf.type_desc,
REVERSE(SUBSTRING(REVERSE(mf.physical_name), 0, CHARINDEX('\', REVERSE(mf.physical_name)))) as 'db_file_name',
LOWER(SUBSTRING(mf.physical_name, 0, LEN(mf.physical_name) - CHARINDEX('\', REVERSE(mf.physical_name)) + 1)) as 'file_path'
from sys.master_files mf
INNER JOIN sys.databases db ON mf.database_id = db.database_id
where mf.database_id IN
(Select database_id from sys.databases
where sys.databases.name = @dbname)

/* Create the scripted commands for the files */

/* Count the number of files to move */
set @numrows = (select count(*) from @info )

/* Create a cursor on @info table */
declare c cursor for select id from @info
open c
fetch next from c into @id

while @@fetch_Status=0 Begin

/* Assign required values into variables from @info db */
select @old_file_location = i.file_path,
@temp_virtual_file_name = i.virtual_file_name,
@new_file_path = case i.type_desc when 'ROWS' then @new_data_file_path when 'LOG' then @new_log_file_path else '' end,
@temp_file_name = i.db_file_name,
@temp_dbname = i.dbname,
@temp_old_file_location = i.file_path
from @info i
where id = @id

/* check if we need to move the files */
if (@old_file_location <> @new_file_path and @new_file_path <>'')

begin
-- select @old_file_location, @new_file_path
/* if we have to move files generate the scripts */

set @num = @num +1
select @num as num, @numrows as numrows
set @tmpString = 'ALTER DATABASE [' + @temp_dbname + '] MODIFY FILE (NAME=[' + @temp_virtual_file_name + '], FILENAME=''' + @new_file_path +'\' + @temp_file_name+ ''')';
insert into @scripts values(@num, @tmpString, 'TSQL')
set @tmpString = 'MOVE /Y "' + @old_file_location + '\' + @temp_file_name + '" "' + @new_file_path +'\' + @temp_file_name + '"'
insert into @scripts values(@num+@numrows+1, @tmpString, 'CMD')
end

fetch next from c into @id
End

if @num > 0
begin
set @tmpString = 'ALTER DATABASE [' + @temp_dbname +'] SET OFFLINE WITH ROLLBACK IMMEDIATE';
insert into @scripts values(@numrows +1, @tmpString, 'TSQL')

set @tmpString = 'ALTER DATABASE [' + @temp_dbname +'] SET ONLINE';
insert into @scripts values(@numrows * 2 +2, @tmpString, 'TSQL')

end
/* Close and deallocate the cursor so we can use it again for dealing with log files */
close c
deallocate c

/* Display the scripts to run */
--select * from @scripts order by step

/* Executes the commands */

if @num > 0
begin
declare c cursor for select scriptText , commtype from @scripts order by step
open c
fetch next from c into @command, @commtype

while @@fetch_Status=0 Begin
if @commtype = 'TSQL'
begin

insert into @message values((select count(*) from @message) + 1, 'Executing TSQL: ' + @command)
EXECUTE sp_executesql @Command;

end
else
begin

insert into @message values((select count(*) from @message) + 1, 'Executing XP Command: ' + @command)
EXEC xp_cmdshell @Command;

end

fetch next from c into @command, @commtype

End
close c
deallocate c
end
else
insert into @message values((select count(*) from @message) + 1, 'DB Files are already in the desired Directories. Nothing to do!' )
end
select message_text from @message order by msg_num
go

------------------------- Script end ------------------------------

Some Considerations about SQL Server editions and pricing

2016-05-06T15:31:00.004+02:00

Firts of all let me say I definitively love SQL Server and I'm really impressed about the product technical improvements in the last years, including the stunning 2016 Version. But at the same time I am worried about the SQL Server market positioning on non-enterprise customers.
Standard Edition price is growing too much, by my opinion.
The free SQL Server Express edition is really too limited in terms of resources to work as a company central repository; Standard Edition can do this job well (altough the 128 GB RAM limitation can easly become a bottleneck), but, in many cases, affording a 10K licences price + the SA fee really becomes a serious obstacle to the product adoption.
Please take in consideration that there are millions of small customers, using only SQL Server standard features as backend for their ERP, accounting software, stock management and so on, that your pricing strategy is pushing away (and this is not only true for SQL Server).
So, although I am quite sure that my words will be lost in the wind, I would like to give some non-technical suggestion:
1) In SQL Server 2012 MS has introduced the BI Edition, why don’t cut off the Standard Edition price as well as the BI features?
2) MS is still selling SQL Server as a product (license) and as a service (Software Assurance); now is giving free licenses to customers migrating from Oracle, but they still have to pay the service (SA). Why don't do a step forward and decide to sell the whole product, for all customers, as a service eliminating the initial licence price?
3) MS is already selling SQL Server nearly as a as a service in contexts like SPLAs,Enterprise Agreements and, of course, Azure
4) By my opinion Software Assurance is creating problems to both MS and Customers: MS is quite obligated to release a new Version every 2 years, and customers have to afford upgrading side costs; I think that adopting a more relaxed versioning can simpify the life to both parts
5) Software Assurance covers the whole product price in about 3 years, please consider the benefits of a costant lifetime entroy and don't be so aggressive in terms of fees
6) In the next years a lot of customers will move to cloud, Azure fee can be seen as a Computing service + a Software Service fee, now if your clients are already paying a monthly SQL Server fee it would be very easy to move from/to the public cloud to/from the private cloud simply adding or removing the computing fee
Other SQL Server experts at the same time are complaining about the Standard Editions features limitations.
I think you have really developed a wonderfull product, but at the some time a discutable marketing strategy, that is positioning your product as an Enterprise solution even for the entry level editions; I hope I shouldn’t reskill myself on PostGress in the next years.

SQL Server: Audit Security events

2016-02-10T10:41:00.004+01:00

Few days ago a customer asked me to implement a security auditing solution for their production instances of SQL Server, to track users and logins management events. I immediately thought about the native SQL Audit function, but there was a problem, all users gain access to SQL Server with the same login, so to identify exactly who I had to capture the hostname field; unfortunately, the available fields in the SQL Server audits are predefined and not mdifiable (at least not easily) and among them the hostname is missing.
At that point I decided to use DDL triggers, which unlike the DML, have not a significant impact in terms of performances.
First of all we have to understand which events intercept, using this query you can have a hierarchical view of available events:

WITH EventsReports (name, PARENT_TYPE, type, level, sort) AS
(
SELECT CONVERT (varchar (255), type_name), PARENT_TYPE, type, 1, CONVERT (varchar (255), type_name)
FROM sys.trigger_event_types
WHERE PARENT_TYPE IS NULL
UNION ALL
SELECT CONVERT (varchar (255), REPLICATE ( '|', level) + e.type_name),
e.parent_type, e.type, level + 1,
CONVERT (varchar (255), RTRIM (sort) + '|' + e.type_name)
FROM sys.trigger_event_types as e
INNER JOIN EventsReports as d
ON e.parent_type = d.type
)
SELECT PARENT_TYPE, type, name
FROM EventsReports
-- where [name] like '% object%'
ORDER BY sort;

The event name is quite explicative, but in the dubt has a look here

So we decided to track these events: DDL_DATABASE_SECURITY_EVENTS, DDL_DATABASE_EVENTS, DDL_SERVER_SECURITY_EVENTS

Then I have built the DDL trigger.

First let's create a DB and the table that will store our events:

Create DataBase AdminDB;
go
use AdminDB;
go
CREATE TABLE dbo.DDL_Security_Audit_LOG ( EventId int NOT NULL IDENTITY (1, 1) PRIMARY KEY, EventTime datetime , DbName nvarchar(100), EventType nvarchar(100) , UserName nvarchar(100) ,HostName nvarchar (100) , EventTSQL nvarchar(3000) , Data_XML xml);

Then our DDL Trigger:

Create TRIGGER [DDL_Security_Audit]
ON ALL SERVER
FOR DDL_DATABASE_SECURITY_EVENTS, DDL_DATABASE_EVENTS, DDL_SERVER_SECURITY_EVENTS
AS
BEGIN

Declare @ObjectName nvarchar(100) = EVENTDATA().value('(/EVENT_INSTANCE/ObjectName)[1]', 'nvarchar(100)')

Declare @EventType nvarchar(100) = EVENTDATA().value('(/EVENT_INSTANCE/EventType)[1]', 'nvarchar(100)')

Declare @DbName nvarchar(100) = isnull( EVENTDATA().value('(/EVENT_INSTANCE/DatabaseName)[1]', 'nvarchar(1000)'),'Master')

Declare @Command nvarchar(1000) = EVENTDATA().value('(/EVENT_INSTANCE/TSQLCommand/CommandText)[1]', 'nvarchar(1000)')

INSERT INTO AdminDB.dbo.DDL_Security_Audit_LOG
VALUES ( GETDATE() , @DbName, @EventType, suser_sname() , HOST_NAME(), @Command, EVENTDATA() )

END
GO

Then remember to create a JOB to purge old data (if you want to)

Declare @CutOffDate datetime = DATEDIFF(d, -30, getdate())
Delete from AdminDB.dbo.DDL_Audit_Security_TABLE_LOG where EventTime < @CutOffDate

Now you have all info you need to monitor your security events at Server and DataBase level.

Just notice in SQL Server there a security hole: no DDL events avalaible for disable Trigger action.

(Thanks to Alessandro, Matteo, Simone and "Rocco" for allowing me to publish this)

SQL Server: Asynchronous DML Triggers

2015-06-26T18:10:00.002+02:00

Great solution using SQL Server Service Broker:
http://www.madeirasql.com/service-broker-asynchronous-triggers/

Use this version of SB_AT_HandleQueue (the original one doesn't work well):

ALTER PROCEDURE [dbo].[SB_AT_HandleQueue]

SET NOCOUNT ON;

SET ARITHABORT ON

DECLARE @msg XML

DECLARE @DlgId UNIQUEIDENTIFIER

DECLARE @Info nvarchar(max)

DECLARE @ErrorsCount int

SET @ErrorsCount = 0

-- Set whether to log verbose status messages before and after each operation

DECLARE @Verbose BIT = 1

-- Allow 10 retries in case of service broker errors

WHILE @ErrorsCount < 10

BEGIN

BEGIN TRANSACTION

BEGIN TRY

-- Make sure queue is active

IF EXISTS (SELECT NULL FROM sys.service_queues

WHERE NAME = 'SB_AT_Request_Queue'

AND is_receive_enabled = 0)

begin

ALTER QUEUE SB_AT_Request_Queue WITH STATUS = ON;

end

-- handle one message at a time

WAITFOR

(

RECEIVE TOP(1)

@msg = convert(xml,message_body),

@DlgId = conversation_handle

FROM dbo.SB_AT_Request_Queue

);

-- exit when waiting has been timed out

IF @@ROWCOUNT = 0

BEGIN

IF @@TRANCOUNT > 0

begin

ROLLBACK TRANSACTION;

BREAK;

end

END

-- Retreive data from xml message

DECLARE

@ProcedureName VARCHAR(1000),

@inserted XML,

@deleted XML

SELECT

@ProcedureName = x.value('(/Request/ProcedureName)[1]','VARCHAR(1000)'),

@inserted = x.query('/Request/inserted/inserted'),

@deleted = x.query('/Request/deleted/deleted')

FROM @msg.nodes('/Request') AS T(X);

-- Log operation start

IF @Verbose = 1

begin

INSERT INTO SB_AT_ServiceBrokerLogs(ErrorSeverity,ErrorMessage,QueueMessage)

VALUES(0,'Starting Process',@msg);

end

-- Encapsulate execution in TRY..CATCH

-- to catch errors in the specific request

BEGIN TRY

-- Execute Request

EXEC @ProcedureName @inserted, @deleted;

END TRY

BEGIN CATCH

-- log operation fail

INSERT INTO SB_AT_ServiceBrokerLogs(ErrorSeverity,ErrorMessage,ErrorLine,ErrorProc,QueueMessage)

VALUES(ERROR_SEVERITY(),ERROR_MESSAGE(),ERROR_LINE(),ERROR_PROCEDURE(),@msg);

END CATCH

-- commit

IF @@TRANCOUNT > 0

begin

COMMIT TRANSACTION;

end

-- Log operation end

IF @Verbose = 1

begin

INSERT INTO SB_AT_ServiceBrokerLogs(ErrorSeverity,ErrorMessage,QueueMessage)

VALUES(0,'Finished Process',@msg);

end

-- reset xml message

SET @msg = NULL;

END TRY

BEGIN CATCH

-- rollback transaction

-- this will also rollback the extraction of the message from the queue

IF @@TRANCOUNT > 0

begin

ROLLBACK TRANSACTION;

end

-- log operation fail

INSERT INTO SB_AT_ServiceBrokerLogs(ErrorSeverity,ErrorMessage,ErrorLine,ErrorProc,QueueMessage)

VALUES(ERROR_SEVERITY(),ERROR_MESSAGE(),ERROR_LINE(),ERROR_PROCEDURE(),@msg);

-- increase error counter

SET @ErrorsCount = @ErrorsCount + 1;

-- wait 5 seconds before retrying

WAITFOR DELAY '00:00:05'

END CATCH

END

Powershell Script to retrieve Domain's Windows and Office Product Keys

2014-03-28T16:37:00.000+01:00

Some customer asked me for this info, because managing Product Keys over the time can become a very time-wasting activity.

First of all you have to enable the Remote Registry Service, as we are in Windows domain, you can easily do this using a GPO

########################################################################################
# Script: GetMsProductKeys.ps1
# Objective: Get Windows and Office Product Keys from all domain computers
# created from: Ruggiero Lauria
# on : 25/03/2014
#
# http://ruggierolauria.blogspot.com
#
# Thanks to:
# http://poshcode.org/4488
# http://gallery.technet.microsoft.com/scriptcenter/Backup-Windows-product-key-b41468c2
########################################################################################

# Start Functions definition

# Get Windows Product Key
function Get-WindowsProductKey
{
   Param (
          [string[]]$Computername = $Env:Computername,
           $version
          )
         $hklm = 2147483650
        # Invoke the WMI RemoteRegistry access provider
        $wmi = [WMIClass] ("\\" + $Computername + "\root\default:StdRegProv")
        # Load DigitalProductId value
        $values = [byte[]]($wmi.getbinaryvalue($hklm,"SOFTWARE\Microsoft\Windows NT\CurrentVersion","DigitalProductId").uvalue)
        # Select the correct decode function based on Windows Version
        if ($version -lt "6.2")
         {
             $keyproductid = Get-Windows7ProductKey($values)
         }
        else
        {
              $keyproductid = Get-Windows8ProductKey($values)
        }
    $keyproductid

   }

#Decode Pre-Windows 8 Product Key
Function Get-Windows7ProductKey($Key)
{
$lookup = [char[]]("B","C","D","F","G","H","J","K","M","P","Q","R","T","V","W","X","Y","2","3","4","6","7","8","9")
        $keyStartIndex = 0x34;
        $keyEndIndex = [int]($keyStartIndex + 15);
        $decodeLength = [int]29
        $decodeStringLength = [int]15
        $decodedChars = new-object char[] $decodeLength
        $hexPid = new-object System.Collections.ArrayList

       for ($i = $keyStartIndex; $i -le $keyEndIndex; $i++){ [void]$hexPid.Add($values[$i]) }
        for ( $i = $decodeLength - 1; $i -ge 0; $i--)
            {
             if (($i + 1) % 6 -eq 0){$decodedChars[$i] = '-'}
             else
               {
                $digitMapIndex = [int]0
                for ($j = $decodeStringLength - 1; $j -ge 0; $j--)
                {
                    $byteValue = [int](($digitMapIndex * [int]256) -bor [byte]$hexPid[$j]);
                    $hexPid[$j] = [byte] ([math]::Floor($byteValue / 24));
                    $digitMapIndex = $byteValue % 24;
                    $decodedChars[$i] = $lookup[$digitMapIndex];
                 }
                }
             }
$keyproduct = ''
$decodedChars | % { $keyproduct+=$_}
$keyproduct
   }
# Decode Windows 8 Product Key
Function Get-Windows8ProductKey($Key)
{
    $Keyoffset = 52
    $isWin8 = [int]($Key[66]/6) -band 1
    $HF7 = 0xF7
    $Key[66] = ($Key[66] -band $HF7) -bOr (($isWin8 -band 2) * 4)
    $i = 24
    [String]$Chars = "BCDFGHJKMPQRTVWXY2346789"
    do
    {
        $Cur = 0
        $X = 14
        Do
        {
            $Cur = $Cur * 256
            $Cur = $Key[$X + $Keyoffset] + $Cur
            $Key[$X + $Keyoffset] = [math]::Floor([double]($Cur/24))
            $Cur = $Cur % 24
            $X = $X - 1
        }while($X -ge 0)
        $i = $i- 1
        $KeyOutput = $Chars.SubString($Cur,1) + $KeyOutput
        $last = $Cur
    }while($i -ge 0)

    $Keypart1 = $KeyOutput.SubString(1,$last)
    $Keypart2 = $KeyOutput.Substring(1,$KeyOutput.length-1)
    if($last -eq 0 )
    {
        $KeyOutput = "N" + $Keypart2
    }
    else
    {
        $KeyOutput = $Keypart2.Insert($Keypart2.IndexOf($Keypart1)+$Keypart1.length,"N")
    }
    $a = $KeyOutput.Substring(0,5)
    $b = $KeyOutput.substring(5,5)
    $c = $KeyOutput.substring(10,5)
    $d = $KeyOutput.substring(15,5)
    $e = $KeyOutput.substring(20,5)
    $keyproduct = $a + "-" + $b + "-"+ $c + "-"+ $d + "-"+ $e
    $keyproduct
}

   # Get Microsoft Office Product Key
    function Get-MSOfficeProductKey {
    Param(
          [string[]]$Computername = $Env:Computername
          )

    $product = @()
    $hklm = 2147483650

   # If DigitalProductId not found in hklm\SOFTWARE\Microsoft\Office\..
   # may be we have Office 32 Bit on 64 bit OS so the registry path becomes: SOFTWARE\Wow6432node\Microsoft\Office\..

    $path = @("SOFTWARE\Wow6432node\Microsoft\Office","SOFTWARE\Microsoft\Office")

    for ($p = 1; $p -ge 0; $p--) {
       # Invoke the WMI RemoteRegistry access provider
        $wmi = [WMIClass] ("\\" + $Computername + "\root\default:StdRegProv")
       #Navigate 3 levels down the registry tree starting from actual $ path to find DigitalProductID
       # i.e. HKLM\SOFTWARE\Microsoft\Office\11.0\Registration\{90120410-6000-11D3-8CFE-0150048383C9}
        $subkeys1 = $wmi.EnumKey($hklm,$path[$p])
        foreach ($subkey1 in $subkeys1.snames) {
            $subkeys2 = $wmi.EnumKey($hklm,$path[$p]+"\$subkey1")
            foreach ($subkey2 in $subkeys2.snames) {
                $subkeys3 = $wmi.EnumKey($hklm,$path[$p]+"\$subkey1\$subkey2")
                foreach ($subkey3 in $subkeys3.snames) {
                    $subkeys4 = $wmi.EnumValues($hklm,$path[$p]+"\$subkey1\$subkey2\$subkey3")
                    foreach ($subkey4 in $subkeys4.snames) {
                        #Looking for DigitalProductID key
                        if ($subkey4 -eq "DigitalProductId") {

                           # Load DigitalProductId value
                           $values = [byte[]]($wmi.getbinaryvalue($hklm,$path[$p]+"\$subkey1\$subkey2\$subkey3","DigitalProductId").uvalue)

                           $p = -1 # Key found: exit from path loop
                            #Decode DigitalProductId
                           $keyproductid = Get-Windows7ProductKey($values)
                           $keyproductid
                        }
                    }
                }
            }
        }
    }
}

# End Functions definition

# Start of Script body

# Define variables
$FilePath = "C:\scripts\ProductKey" # Change with your own path (must be created!) to store CSV output
$NewCSVObject = @()

# Write Columns headers: first output line

$NewCSVObject | Select "ClientName","OSArchitecture", "Username" , "Manufacturer", "Model", "Dev SerialNumber" ,"Office Version","Office SN", "Caption", "Version", "RegisteredUser", "OS SerialNumber", "WindowsPK" | Format-Table -AutoSize

# Get the list of active computer in AD.

Import-Module ActiveDirectory
$arrComputers = Get-ADComputer -Filter {enabled -eq $true} -properties *|select name | sort name

#$arrComputers = Get-ADComputer -Filter {enabled -eq $true} -properties *|Where {$_.name -like "nb-ac*"} |select name | sort name

# Computers Loop
foreach ($strComputer in $arrComputers)
{
Write-Host $strComputer.name
#Try to connect to the computer
If (Test-Connection -ComputerName $strComputer.name -Count 1 -Quiet) {

try {
    #Inizialize a new row
    $objInfo = New-Object PSObject | Select "ClientName", "OSArchitecture", "Username" ,"Manufacturer", "Model", "DevSerialNumber" ,"OfficeVersion", "OfficeSN", "Caption", "Version","RegisteredUser", "OSSerialNumber", "WindowsPK"

    # Get currently logged in username, client name, manufacturer and model from Win32_ComputerSystem class.
    $colItems = Get-WmiObject Win32_ComputerSystem -Namespace "root\CIMV2" -ErrorAction stop -ComputerName $strComputer.name

    foreach($objItem in $colItems) {
     $objInfo.Username= $objItem.UserName
     $objInfo.ClientName = $objItem.Name
     $objInfo.Manufacturer = $objItem.Manufacturer
     $objInfo.Model = $objItem.Model
     }

    # Get workstation serial number from Win32_BIOS class.
    $colItems = Get-WmiObject Win32_BIOS -Namespace "root\CIMV2" -ErrorAction stop -ComputerName $strComputer.name

    foreach($objItem in $colItems) {
    $objInfo.DevSerialNumber = $objItem.SerialNumber
     }

    #Get OS Info from Win32_OperatingSystem
    $colItems = Get-WmiObject Win32_OperatingSystem -ErrorAction Stop -ComputerName $strComputer.name
    foreach($objItem in $colItems) {
    if ($objItem.OSArchitecture) {$objInfo.OSArchitecture = $objItem.OSArchitecture} else { $objInfo.OSArchitecture ="32 bit" }
    $objInfo.Caption = $objItem.Caption
    $objInfo.Version = $objItem.Version
    $objInfo.RegisteredUser= $objItem.RegisteredUser
    $objInfo.OsSerialNumber= $objItem.SerialNumber
      }

    #Get MS Windows Serial Number
    #write-host $objInfo.Version
    $objInfo.WindowsPK = Get-WindowsProductKey -Computername $strComputer.name -Version $objInfo.Version

    #Get Office Version from WIn32_Product
    $colItems = Get-WmiObject WIn32_Product -Computername $strComputer.name -Filter "Name like '%Office%'"| Where {($_.ProductID) }
    foreach($objItem in $colItems) {
    $objInfo.OfficeVersion = $objItem.Name
     }
    if ($objInfo.OfficeVersion) {

    #Get Office Serial Number
    $objInfo.OfficeSN = Get-MSOfficeProductKey -Computername $strComputer.name
     }
    else {
    $objInfo.OfficeVersion = "Office not installed"
    }
}
catch # If we get any error Reading computer data let's say it is Unreadable
{
    $objInfo = New-Object PSObject | Select "ClientName", "OSArchitecture", "Username" ,"Manufacturer", "Model", "DevSerialNumber" ,"OfficeVersion", "OfficeSN", "Caption", "Version","RegisteredUser", "OSSerialNumber", "WindowsPK"
    $objInfo.ClientName = $strComputer.name
    $objInfo.OSArchitecture = 'Unreadable'
   }
}
# If we are unable to connect let's say the computer is Unreachable
else
    {
    $objInfo = New-Object PSObject | Select "ClientName", "OSArchitecture", "Username" ,"Manufacturer", "Model", "DevSerialNumber" ,"OfficeVersion", "OfficeSN", "Caption", "Version","RegisteredUser", "OSSerialNumber", "WindowsPK"
        $objInfo.ClientName = $strComputer.name
        $objInfo.OSArchitecture = 'Unreachable'
     }
# Add a new Row with current computer data
$NewCSVObject += $objInfo
$objInfo=""

}

# OutPut to CSV file
# If you want a video output too uncomment line below
$NewCSVObject |Out-GridView
$NewCSVObject | export-csv "$FilePath\ListPK_$(Get-Date -f yyyy-MM-dd).csv" -noType

# End of Script body
###################################################################

I Forum di Technet

2013-10-28T16:42:00.001+01:00

Magari fornisco un'informazione già nota, ma c'è una importante risorsa tecnica a volte sottovalutata.
Alle volte, a prescindere dalla propria preparazione, capita a tutti i bloccarsi su qualche problema e nonostante possiamo essere degli ottimi "googleatori" o "bingatori" non riusciamo a venirne fuori.
Prima di aprire una chiamata con Microsoft esiste una possibilità assolutamente gratutita che ci viene incontro:
i forum di technet : http://social.technet.microsoft.com/Forums/it-it/home

All'interno di questi forum ci sono moltissimi esperti, spesso MVP (Most Valuable Professional), che danno assistenza agli utenti per aiutarli a risolvere i problemi tecnici in tempi molto veloci (non esiste una garanzia in tal senso, ma normalmente si parla di minuti al massimo di ore).
Quindi il mio suggerimento è, prima di provare altre strade, sottoponete il vostro problema nel Forum di Technet, potreste avere delle piacevolissime sorprese ;)

Windows Server 2012 GUI management

2013-04-16T16:52:00.003+02:00

Windows server 2012 introduces the ability to switch from a Core to a FULL or a Partial GUI installation and viceversa.
Here are Powershell commands:

To switch from Server Core to partial GUI mode:
Install-WindowsFeature Server-Gui-Mgmt-Infra -Restart

To switch from Server Core to full GUI mode:
Install-WindowsFeature Server-Gui-Mgmt-Infra Server-Gui-Shell -Restart

To switch from Server Core to full GUI mode with the desktop experience installed:
Install-WindowsFeature Server-Gui-Mgmt-Infra Server-Gui-Shell Desktop-Experience -Restart

To switch from Full installation to Server Core:
Uninstall-WindowsFeature Server-Gui-Mgmt-Infra -Restart

To switch from Full installation to partial GUI mode:
Uninstall-WindowsFeature Server-Gui-Shell -Restart

To identify your level of GUI use:
Get-WindowsFeature *gui*

SQL Injection Attack!

2013-03-19T20:31:00.002+01:00

It's a radar video system capturing car license number plates... then have a look at the car plate content in the last picture

LOL!!!!

Detail:

Command:

ZU 0666’, 0, 0); Drop Database Tablice; --

Note: TABLICE in Polish = TABLES in English

and zwolnij = slow down

Data Protection Manager Reports ed Exchange

2013-03-14T12:16:00.004+01:00

Problema: nonostante sia correttamente configurato l'SMTP su Exchange la sottoscrizione ai report via mail non funziona e non viene creato nessun evento di errore.

Soluzione: creare su Exchange un nuovo connettore di ricezione

Indicare l'indirizzo IP del Server DPM

Specificare l'autenticazione TLS e Protetto Esternamente

Selezioanare Utenti anonimi, Utenti Exchange, Server Exchange e Partner

Adesso dovrebbe funzionare tutto

SQL Server 2012 AlwaysOn

2013-02-18T00:34:00.001+01:00

Introduction

One of the greatest new features introduced in SQL Server 2012 in terms of high availability is the AlwaysOn technology.
This is divided into two types:

AlwaysOn Failover Cluster Instance: Protection at single instance level, improvement of the traditional SQL Server Cluster installation, mainly in the health monitoring and Multi-Subnet implementation.
AlwaysOn Availability Group: Database-level security, evolution of the earlier SQL Server versions DB mirroring.

Source: Microsoft Learning

First solution, in terms of architecture, just adds elimination of the need to create a VLAN for cluster nodes, while Availability groups are a true novelty, perhaps one of that particular for which it would be worth to migrate to SQL 2012.

AlwaysOn Availability Group

General

This technology takes advantage of the Windows Server Failover Cluster (WSFC) to provide a high availability solution for SQL Server databases. It 'an evolution of DB mirroring technology, introduced with SQL Server 2005 version, but offers these fundamental additional advantages:

Nodes number is no longer limited to 2
Failover is no longer handled by the client, but it's a server side event done in a transparent way to the client
And' possible to perform read-only access to a passive node of the availability group
And' possible to perform the backup operations on a passive node of the availability group

Although this technology is based on the Failover Cluster is not necessary:

Have a storage shared among cluster nodes
Perform an SQL Server Cluster installation

Then each node will have a standalone SQL Server installation with data on local node storage.

Note:

In Windows Server 2012 Failover Cluster feature is available also on the standard version

There is no problem in creating virtualized nodes, if not the usual recommendations for SQL Server running on a virtual machine

Terminology

Source: Microsoft Learning

AlwaysOn Availability Group: a group of servers (cluster) that provides high availability to one or more databases

Primary Replica: SQL Server instance that hosts the read and write Database copy (only one among group)

Secondary Replica: node that hosts a Database copy on which you can enable read-only access

Listener: consists of a DNS name, TCP port, and one or more IP addresses through which clients connect to the availability group

Availability Modes: how data is replicated between the primary and a secondary member, can be:

Commit-Synchronous: the primary replica waits for confirmation that the changes have been made on the secondary member before closing the transaction. Reliable but dangerous in terms of performances.
Commit-Asynchronous: the primary member sends changes to the secondary and close the transaction without waiting for any confirmation of the outcome. Not reliable but very performing.

Failover: process through which the role of the Primary Replica is passed to a Secondary Replica, called failover target. There are 3 types of failover:

Automatic failover (without data loss) available when both the primary that the secondary replica are operating in synchronous mode (Commit-Synchronous). In this case the failover mode in the group is set to automatic and the passage of roles takes place without any administrative intervention.
Planned manual failover (without data loss): as in the previous case, the two members operate in synchronous mode, but, since the Group was not set to Automatic failover. requires an administrative intervention to send the failover command.
Forced manual failover (with possible data loss): the two replica members operate asynchronously and then the administrator can force the failover knowing that any transactions that have not yet been synchronized from the primary member will be lost.

Active Secondary Replica: to improve performance and manage more efficiently the availability group resources you can route read-only and backup requests to a secondary replica; secondary replica(s) acting in this way is/are called 'active'

Installation

Note: the objective of this article is centered on the Availability Group and not on the Failover Cluster configuration, so I will not go into detail on this part.

1) Install the Failover Cluster feature on each Server

2) Create a Failover Cluster that includes all servers

in our example we have created a cluster called MIA-CLUSTER including the servers:

MIA-CLUST1

MIA-CLUST2

MIA-CLUST3

Note that there is no shared storage in the cluster.

3) Install a Standalone instance of SQL Server 2012 on each server

Note:

Use a domain account for the SQL Service

You can install only the Database Engine feature, optionally also management tools

4) Trough the SQL Server Configuration Manager enabled AlwaysOn Availability Group on each server

Note: Restart the SQL Server service

5) Create a network share for the backup files used to synchronize the replicas

6) Create Database(s) we want to protect on the Server that will become your Primary Replica

In our case the Server that will act as Primary Replica is MIA-CLUST1 and we'll put in High Availability the Sales database

Check that the Database Recovery Model is Full

7) Now you can create your AlwaysOn Avalaibilty Group

Launch the Wizard on the Primary Server

Specify your AG name (in our case MIA-SQL-AG)

We select the Sales database

Add the Secondary Replicas: Add Replica ...

Configure the Listener

We set the synchronization folder

Then let's go Next

Control the outcome

Note: the warning I received about the WSFC is not significant

Final Results:

The Sales database is replicated on all three Servers

In the cluster was created a service whose onwer is our Primary Replica

Configuration

Now let's do a configuration example.

We enter our Group Availability properties

We set MIA-CLUST2 in synchronous mode and we enable automatic failover
Let MIA-CLUST3 in asynchronous mode, and then the failover can only be manual
We make both Secondary Replicas readable

Let's analyze deeper the available options.

Remember that each server can potentially act in two modes: Primary and Secondary, here we have options available for each server based on the role it plays (state is intended to be dynamic):

Connections in primary role: when acting as a primary replica server can accept all or only write connections

Readable Secondary: when acting as a secondary a server can: don't accept connections (passive), accept any connection (but operation will fail if you try to change data) or accept only connections that explicitly define Intent = Readonly

Then we go in the Backup Preferences

We leave the default to Prefer Secondary, in this way the backup will always be performed on a secondary replica, if available.
We also change the backup priority by putting up MIA-CLUST3 Server.

Our settings results are also visible from the AG Dashboard

READ-ONLY ROUTING

After making our secondary replicas readable it's already possible to access them pointing directly to the server name.
Access example to MIA-CLUST2

Access example to MIA-CLUST3 (set to read-only intent, note the error in the first attempt)

But if we want to create a mechanism that automatically addresses read-only requests to Secondary Replicas we have to implement Read-Only Routing.

For details about the configuration you can refer to this article, but let's do it togheter:

You must have configured a Listener and we did it in the AG configuration wizard:

            DNS: MIA-SQL-CLUSTER
            IP: 10.10.0.40
           TCP Port: 1433

Identify each AG server member connection URLs, in our case:

       TCP://MIA-CLUST1.AdventureWorks.msft:1433
           TCP://MIA-CLUST2.AdventureWorks.msft:1433
           TCP://MIA-CLUST3.AdventureWorks.msft:1433
    As you can see URLs contain the Listener Configuration (TCP 1433) and the server FQDN

    However to obtain URLs you can use this script created by Matt Neerincx that provides an output like :

Configure Read_only_routing using these TSQL commands on your Primary Replica:

__________________________ Start _________________________________________

-- Configure Read_Only_Routing

-- This script needs to be paramatrized with your deployment data!!!!

-- by Ruggiero Lauria

-- Enable Server as Readable when acting as Secondary Replica

-- This command is not strictly necessary because we have already configured it

-- trough AG propriety. But for completeness I preferred to include it in the script

ALTER AVAILABILITY GROUP [MIA-SQL-AG]

MODIFY REPLICA ON

N'MIA-CLUST1' WITH

(SECONDARY_ROLE (ALLOW_CONNECTIONS = READ_ONLY));

-- Define the Server Read_only_routing URL

ALTER AVAILABILITY GROUP [MIA-SQL-AG]

MODIFY REPLICA ON

N'MIA-CLUST1' WITH

(SECONDARY_ROLE (READ_ONLY_ROUTING_URL = N'TCP://MIA-CLUST1.AdventureWorks.msft:1433'));

-- Enable Server as Readable when acting as Secondary Replica

-- This command is not strictly necessary because we have already configured it

-- trough AG propriety. But for completeness I preferred to include it in the script

ALTER AVAILABILITY GROUP [MIA-SQL-AG]

MODIFY REPLICA ON

N'MIA-CLUST2' WITH

(SECONDARY_ROLE (ALLOW_CONNECTIONS = READ_ONLY));

-- Define Server Read_only_routing URL

ALTER AVAILABILITY GROUP [MIA-SQL-AG]

MODIFY REPLICA ON

N'MIA-CLUST2' WITH

(SECONDARY_ROLE (READ_ONLY_ROUTING_URL = N'TCP://MIA-CLUST2.AdventureWorks.msft:1433'));

-- Enable Server as Readable when acting as Secondary Replica

-- This command is not strictly necessary because we have already configured it

-- trough AG propriety. But for completeness I preferred to include it in the script

ALTER AVAILABILITY GROUP [MIA-SQL-AG]

MODIFY REPLICA ON

N'MIA-CLUST3' WITH

(SECONDARY_ROLE (ALLOW_CONNECTIONS = READ_ONLY));

-- Define Server Read_only_routing URL

ALTER AVAILABILITY GROUP [MIA-SQL-AG]

MODIFY REPLICA ON

N'MIA-CLUST3' WITH

(SECONDARY_ROLE (READ_ONLY_ROUTING_URL = N'TCP://MIA-CLUST3.AdventureWorks.msft:1433'));

-- Define Read Routing List when Server is acting as Primary Replica

ALTER AVAILABILITY GROUP [MIA-SQL-AG]

MODIFY REPLICA ON

N'MIA-CLUST1' WITH

(PRIMARY_ROLE (READ_ONLY_ROUTING_LIST=('MIA-CLUST2','MIA-CLUST3')));

-- Define Read Routing List when Server is acting as Primary Replica

ALTER AVAILABILITY GROUP [MIA-SQL-AG]

MODIFY REPLICA ON

N'MIA-CLUST2' WITH

(PRIMARY_ROLE (READ_ONLY_ROUTING_LIST=('MIA-CLUST1','MIA-CLUST3')));

-- Define Read Routing List when Server is acting as Primary Replica

ALTER AVAILABILITY GROUP [MIA-SQL-AG]

MODIFY REPLICA ON

N'MIA-CLUST3' WITH

(PRIMARY_ROLE (READ_ONLY_ROUTING_LIST=('MIA-CLUST1','MIA-CLUST2')));

GO

_______________________________End _________________________________________

Note: Servers indicated in the routing lists will be used in sequence based on availability, there is no form of load balancing or round robin.

Connectivity Test

Here is the process used by the Read Only Routing:

Clients connect to our Availability Group Listener
Client request is redirected (always!) to the Primary Replica
Client has specified in the connection string ApplicationIntent=ReadOnly
Sever checks if the target database is member of an Availability Group
If it is true step 4, server checks if it is set a read_only_routing_list on the Primary Replica
If it is true step 5 server checks, in order, that the servers listed in Routing_List are synchronizing and accepting connections (allow_connections = read_only or all)
Server reads from the read_only_routing_url the first secondary replica ready to accept connections and passes it's URL to the client
The client reads the URL and redirects itself to the secondary readable instance

To test connectivity we'll now use SQL Server Reporting Services, in this example I'll make a simple report (the example is trivial!) on the Sales.dbo.orders table , including the name of the responding server, using the following query:

Select OrderDate, OrderTotal, @@ServerName as Server from Orders

First Test: we access with ApplicationIntent = ReadWrite

And we receive answer from the Primary Replica

And now let's change the connection type with ApplicationIntent=ReadOnly

And resubmitting our report we obtain

We have been routed to the first server in the routing list defined for Primary Replica, remember:

ALTER AVAILABILITY GROUP [MIA-SQL-AG]

MODIFY REPLICA ON

N'MIA-CLUST1' WITH

(PRIMARY_ROLE (READ_ONLY_ROUTING_LIST=('MIA-CLUST2','MIA-CLUST3')));

Useful Commands

Connection string example:
Server=tcp:MIA-SQL-CLUST,1433;Database=Sales;IntegratedSecurity=SSPI;ApplicationIntent=ReadOnly;MultiSubnetFailover=True

Listener Restart:

ALTER AVAILABILITY GROUP [MIA-SQL-AG] RESTART LISTENER 'MIA-SQL-CLUST';

Related System Views

SELECT * FROM sys.dm_tcp_listener_states

SELECT * from sys.availability_replicas

SELECT * from sys.availability_read_only_routing_lists

Ending

I hope that this step by step guide will help you to take full advantages of this wonderful opportunity offered by SQL Server 2012.
Any corrections and comments are welcome

That's it, have fun!

SQL Server 2012 AlwaysOn

2013-02-11T18:25:00.003+01:00

english version

Introduzione

Una delle più grandi novità introdotte da SQL Server 2012 sotto il profilo dell' alta disponibilità è la tecnologia AlwaysOn.
Questa si suddivide in due tipologie:

AlwaysOn Failover Cluster Instance: Protezione a livello di singola istanza, miglioramento della tradizionale installazione in Cluster di SQL Server nel monitoraggio dello stato di salute e nelle implementazioni Multi-Subnet
AlwaysOn Availability Group: Protezione a livello di Database, evoluzione del DB mirroring delle versioni precedenti di SQL Server


Source: Microsoft Learning

La prima soluzione in termini archietturali poco aggiunge alle precedenti versioni se non l'eliminazione della necessità di creazione di una VLAN per i nodi del cluster; invece i gruppi di diponibilità sono una vera novità, forse uno di quei particolari per cui varrebbe la pena di migrare ad SQL 2012.

AlwaysOn Availability Group

Generale

Questa tecnologia sfrutta i vantaggi offerti dal Windows Server Failover Cluster (WSFC) per fornire una soluzione di alta disponibilità per i Database SQL Server. E' un evoluzione della tecnologia di DB mirroring, introdotta con la versione SQL Server 2005, ma offre questi fondamentali vantaggi aggiuntivi:

Il numero dei nodi non è più limitato a 2
Il failover non è più fatto dal client, ma avviene lato server in maniera trasparente per i client
E' possibile accedere in sola lettura ad un nodo passivo del gruppo di disponibilità
E' possibile eseguire le operazioni di backup su un nodo passivo del gruppo di disponibilità

Nonostante questa tecnologia si basi sul Failover Cluster non è necessario:

Avere uno storage condiviso fra i nodi del cluster
Fare un installazione in Cluster di SQL Server

Quindi ogni nodo avrà un'installazione autonoma di SQL Server con i dati su uno storage locale del nodo.

Note:

In Windows Server 2012 la funzionalità di Failover Cluster è disponibile anche sulla versione Standard
Non esiste nessun problema nel creare nodi virtualizzati, se non le solite raccomandazioni relative al fare girare SQL Server su una macchina virtuale

Terminologia

Source: Microsoft Learning

AlwaysOn Availability Group: gruppo di server (in cluster) che mette in alta disponibilità uno o più Database
Primary Replica: istanza che ospita la copia in lettura e scrittura del Database

Secondary Replica: host che ospita una copia del database su cui è possibile abilitare accessi in sola lettura

Listener: consiste di un nome DNS, una porta TCP ed uno o più indirizzi IP attraverso cui i client si connettono al gruppo di disponibilità
Availability Modes: modalità di replica dei dati fra il membro primario ed i secondari, può essere:

Commit-Synchronous: la replica primaria attende conferma che le modifiche siano state apportate sul membro secondario prima di chiudere la transazione. Affidabile ma pericoloso per le performances
Commit-Asynchronous: il membro primario invia le modifiche al secondario e chiude la transazione senza aspettare conferma sull'esito.Non affidabile ma performante.

Failover: processo attraverso il quale il ruolo di replica primaria viene passato ad una replica secondaria, chiamata failover target. Sono disponibili 3 tipi di failover:

Failover automatico (senza perdita di dati): disponibile quando sia la replica primaria che la secondaria operano in modalità sincrona (Commit-Synchronous). In questo caso la modalità di failover nel gruppo è impostata su automatica ed il passaggio di ruoli avviene senza alcun intervento amministrativo.
Failover manuale pianificato (senza perdita di dati): come nel caso precedente i due membri operano in modalità sincrona, ma non essendo stato impostato il failover automatico è necessario l'intervento amministrativo per inviare il comando di failover.
Failover manuale forzato (con possibile perdita di dati): i due membri di replica operano in modalità asincrona e quindi l'amministratore può forzare il failover sapendo che eventuali transazioni del membro primario non ancora sincronizzate andranno perse.

Active Secondary Replicas: per migliorare le performance e gestire in maniera più efficiente le risorse del gruppo di disponibilità è possibile indirizzare le richieste di sola lettura e backup verso repliche secondarie

Installazione

L'obiettivo di questo articolo è centrato sugli Availability Group e non sulla configurazione del Cluster di Failover, quindi non entrerò nei dettagli su questa parte.

1) Installare la funzionalità di Failover Cluster sui Server

2) Creare un Cluster di Failover che comprenda tutti i Server

nel nostro esempio abbiamo creato un cluster MIA-CLUSTER a cui partecipano i server:
MIA-CLUST1
MIA-CLUST2
MIA-CLUST3

Notare che nel Cluster non c'è Storage condiviso.

3) Installare un'istanza Standalone di SQL Server 2012 su ogni Server

Note:

Usate un account di dominio per il Servizio SQL
Potete installare solo il Motore di Database, opzionalmente anche gli strumenti di gestione

4) Attaverso il Configuration Manager abilitate AlwaysOn Availability Group su ogni Server

Riavviate i servizi di SQL Server

5) Create una condivisione di rete per i file di Backup utilizzati per sincronizzare le repliche

6) Creiamo i DataBase che vogliamo proteggere sul Server che diventerà la Replica Primaria

Nel nostro caso il Server che svolgerà il ruolo di Replica Primaria è MIA-CLUST1 e mettiamo in alta disponibilità il Database Sales
Controllate che il Recovery Model sia Full

7) Creiamo un AlwaysOn Avalaibilty Group

Lanciamo il Wizard dal Server Primario

Specifichiamo il nome del nostro AG

Selezioniamo il database Sales

Aggiungiamo le Repliche Secondarie: Add Replica...

Configuriamo il Listener

Impostiamo il Folder per la sincronizzazione

Controlliamo l'esito

Il warning ricevuto relativo al WSFC è trascurabile

Risultato Finale:

Il Database Sales è replicato su tutti e tre i Server

Nel cluster è stato creato un servizio il cui Onwer è il nostro Primary Replica

Configurazione

Adesso facciamo un esempio di configurazione.
Entriamo nelle proprietà del nostro Availability Group

Impostiamo MIA-CLUST2 in modalità sincrona ed abilitiamo il failover automatico
Lasciamo MIA-CLUST3 in modalità asincrona, e quindi il failover può essere solo manuale
Rendiamo ambedue le Repliche Secondarie leggibili ed analizziamo meglio le opzioni disponibili.
Ricordiamo che ogni server può potenzialmente agire in due modalità: Primario e Secondario, qui abbiamo le opzioni disponibili per ogni server in base al ruolo che svolge (la situazione può essere dinamica):

Connections in primary role: quando agisce da primario, può accettare tutte le connessioni o solo quelle in scrittura.

Readable Secondary: quando agisce da secondario può non accettare connessioni, accettarle tutte (ma dare errore se si prova a modificare i dati) o accettare solo le connessioni che abbiano esplicitamente Intent=Readonly

Andiamo poi nella sezione Backup Preferences
Lasciamo il default a Prefer Secondary, in questo modo i backup verrano sempre fatti sui secondari, se disponibili.
Cambiamo la priorità del backup mettendo avanti il Server MIA-CLUST3

I risultati delle nostre impostazioni sono anche visibili dalla Dashboard dell' AG

READ-ONLY ROUTING

Dopo aver reso le nostre repliche secondarie leggibili già possible accedervi puntando direttamente al nome del Server.
Esempio di accesso al MIA-CLUST2

Esempio di accesso a MIA-CLUST3 (impostato read-intent only, notare l'errore nel primo tentativo)

Ma se vogliamo creare un meccanismo che indirizzi automaticamente le richieste di sola lettura verso le Repliche Secondarie dobbiamo implementare in Read-Only Routing.

Per la configurazione potete fare riferimento a questo articolo ma riassumendo:

Dobbiamo avere configurato un Listener e noi lo abbiamo fatto nel wizard:

DNS: MIA-SQL-CLUSTER
IP: 10.10.0.40
TCP Port: 1433

Identifichiamo la URL per connessione ad ogni Server membro del nostro AG

           Nel nostro caso: TCP://MIA-CLUST1.AdventureWorks.msft:1433
                                     TCP://MIA-CLUST2.AdventureWorks.msft:1433
                           TCP://MIA-CLUST3.AdventureWorks.msft:1433
Potete utilizzare questo script realizzato da Matt Neerincx che fornisce un output del tipo

Configuriamo i nostri Read_only_routing dando questi comandi sulla nostra Replica Primaria:

___________________ Start ____________________________
-- Configure Read_Only_Routing
-- This script need to be paramatrized with your deployment data!
-- Ruggiero Lauria

-- Enable Server as Readable when acting as Secondary Replica
-- This command is not strictly necessary because we have already configured it
-- trough AG propriety. But for completeness I preferred to include it in the script
ALTER AVAILABILITY GROUP [MIA-SQL-AG]
MODIFY REPLICA ON
N'MIA-CLUST1' WITH
(SECONDARY_ROLE (ALLOW_CONNECTIONS = READ_ONLY));

-- Define Server Read_only_routing URL

ALTER AVAILABILITY GROUP [MIA-SQL-AG]
MODIFY REPLICA ON
N'MIA-CLUST1' WITH
(SECONDARY_ROLE (READ_ONLY_ROUTING_URL = N'TCP://MIA-CLUST1.AdventureWorks.msft:1433'));

-- Enable Server as Readable when acting as Secondary Replica

-- This command is not strictly necessary because we have already configured it
-- trough AG propriety. But for completeness I preferred to include it in the script
ALTER AVAILABILITY GROUP [MIA-SQL-AG]
MODIFY REPLICA ON
N'MIA-CLUST2' WITH
(SECONDARY_ROLE (ALLOW_CONNECTIONS = READ_ONLY));

-- Define Server Read_only_routing URL

ALTER AVAILABILITY GROUP [MIA-SQL-AG]
MODIFY REPLICA ON
N'MIA-CLUST2' WITH
(SECONDARY_ROLE (READ_ONLY_ROUTING_URL = N'TCP://MIA-CLUST2.AdventureWorks.msft:1433'));

-- Enable Server as Readable when acting as Secondary Replica
-- This command is not strictly necessary because we have already configured it
-- trough AG propriety. But for completeness I preferred to include it in the script

ALTER AVAILABILITY GROUP [MIA-SQL-AG]
MODIFY REPLICA ON
N'MIA-CLUST3' WITH
(SECONDARY_ROLE (ALLOW_CONNECTIONS = READ_ONLY));

-- Define Server Read_only_routing URL

ALTER AVAILABILITY GROUP [MIA-SQL-AG]
MODIFY REPLICA ON
N'MIA-CLUST3' WITH
(SECONDARY_ROLE (READ_ONLY_ROUTING_URL = N'TCP://MIA-CLUST3.AdventureWorks.msft:1433'));

-- Define Read Routing List when Server is acting as Primary Replica

ALTER AVAILABILITY GROUP [MIA-SQL-AG]
MODIFY REPLICA ON
N'MIA-CLUST1' WITH
(PRIMARY_ROLE (READ_ONLY_ROUTING_LIST=('MIA-CLUST2','MIA-CLUST3')));

-- Define Read Routing List when Server is acting as Primary Replica

ALTER AVAILABILITY GROUP [MIA-SQL-AG]
MODIFY REPLICA ON
N'MIA-CLUST2' WITH
(PRIMARY_ROLE (READ_ONLY_ROUTING_LIST=('MIA-CLUST1','MIA-CLUST3')));

-- Define Read Routing List when Server is acting as Primary Replica

ALTER AVAILABILITY GROUP [MIA-SQL-AG]
MODIFY REPLICA ON
N'MIA-CLUST3' WITH
(PRIMARY_ROLE (READ_ONLY_ROUTING_LIST=('MIA-CLUST1','MIA-CLUST2')));
GO
_________________End ________________________

Nota: I Server indicati nella routing list verranno usati in sequenza in base alla disponibilità, non esiste alcuna forma di Load Balancing o round robin.

Test di connettività

Di seguito il processo utilizzato dal Read Only Routing:

Il client si connettono al Listener del nostro Availability Group
Il client viene reindirizzato (sempre!) verso la Primary Replica
Il client ha specificato nella stringa di connessione ApplicationIntent=ReadOnly
Il sever controlla che il database di destinazione faccia parte di un Availability Group
Se è vero il punto 4, il server controlla se è impostata una read_only_routing_list sulla Primary Replica
Se è vero il punto 5 il server controlla in ordine che i server elencati nella Routing_List stiano sincronizzando ed accettino connessioni (allow_connections=read_only or all)
Il server legge la read_only_routing_url della prima replica secondaria pronta ad accettare connessioni e la passa al client
Il client legge la URL e si ridireziona verso l'istanza secondaria leggibile

Per eseguire un test di connettività si possono utilizzare i Reporting Services, quindi nel nostro esempio farò un semplice report (l'esempio è banale!) sulla tabella sales.dbo.orders includendo il nome del server che sta rispondendo con la seguente query:

Select OrderDate, OrderTotal, @@ServerName as Server from Orders

Primo Test: accediamo con ApplicationIntent=ReadWrite

E riceviamo risposta dalla Primary Replica

Adesso cambiamo il tipo di connessione in ApplicationIntent=ReadOnly

E rilanciando il report

Siamo stati reindirizzati verso il primo server della routing list definita per Primary Replica:

ALTER AVAILABILITY GROUP [MIA-SQL-AG]
MODIFY REPLICA ON
N'MIA-CLUST1' WITH
(PRIMARY_ROLE (READ_ONLY_ROUTING_LIST=('MIA-CLUST2','MIA-CLUST3')));

Comandi Utili

Esempio di stringa di connessione:

Server=tcp:MIA-SQL-CLUST,1433;Database=Sales;IntegratedSecurity=SSPI;ApplicationIntent=ReadOnly;MultiSubnetFailover=True

Restart del listener

ALTER AVAILABILITY GROUP [MIA-SQL-AG] RESTART LISTENER 'MIA-SQL-CLUST';

Related System Views

SELECT * FROM sys.dm_tcp_listener_states

SELECT * from sys.availability_replicas

SELECT * from sys.availability_read_only_routing_lists

Conclusione

Spero che questa guida passo passo possa esservi di aiuto per sfruttare appieno questa opportunità che ci viene offerta da SQL Server 2012.
Tutte le correzioni ed i commenti sono i benvenuti
Buon divertimento!

Gestione Hyper-V tramite Power Shell

2013-02-05T19:01:00.000+01:00

Ottimo componente per la gestione dell' Hyper-V e della macchine virtuali tramite la Power Shell:
Codeplex

CoreConfig Security Warning

2012-12-19T14:53:00.000+01:00

Launching: "cscript Start_CoreConfig.wsf"

You'll be asked to confirm every operation

Security Warning
Run only scripts that you trust. While scripts from the Internet can be useful, this script can potentially harm your computer. Do you want to run C:\Utility\CoreConfig\CoreConfig.ps1?
[D] Do not run [R] Run once [S] Suspend [?] Help (default is "D"):

To solve this go to CoreConfig installation folder,edit Start_CoreConfig.wsf and substitute:

Function LaunchCoreConfig()
'========================
Dim iRetCode
Dim Temp
'
LaunchCoreConfig = False
'
On Error Resume Next
WshShell.RegWrite"HKLM\Software\Microsoft\Powershell\1\ShellIds
\Microsoft.PowerShell\ExecutionPolicy", "Unrestricted", "REG_SZ"
On Error goto 0
'
WshShell.CurrentDirectory = GlobalFolderPath
iRetCode = WshShell.Run ("C:\Windows\system32\WindowsPowerShell\v1.0\powershell.exe -WindowStyle Minimized -Sta -file CoreConfig.ps1", 1, True)
If iRetCode <> 0 Then
Call Debug("Error: During launch of CoreConfig! ReturnCode:" & iRetCode)
Call WshShell.Popup("Error: During launch of CoreConfig! ReturnCode:" & iRetCode & Vbcrlf & " Please copy source to local drive and try again!" ,0,"Error", 16)
Else
'Okay
LaunchCoreConfig = True
End If
End Function

with

Function LaunchCoreConfig()
'========================
Dim iRetCode
Dim Temp
'
LaunchCoreConfig = False
'

On Error goto 0
'
WshShell.CurrentDirectory = GlobalFolderPath
iRetCode = WshShell.Run ("%SystemRoot%\system32\WindowsPowerShell\v1.0\powershell.exe -executionpolicy bypass -WindowStyle Minimized -Sta -file CoreConfig.ps1", 1, True)
If iRetCode <> 0 Then
Call Debug("Error: During launch of CoreConfig! ReturnCode:" & iRetCode)
Call WshShell.Popup("Error: During launch of CoreConfig! ReturnCode:" & iRetCode & Vbcrlf & " Please copy source to local drive and try again!" ,0,"Error", 16)
Else
'Okay
LaunchCoreConfig = True
End If
End Function

Explanation:
First of all is not a good solution to set execution policy to unrestricted for all Powershell scripts changing Reg Key:
WshShell.RegWrite"HKLM\Software\Microsoft\Powershell\1\ShellIds\Microsoft.PowerShell\ExecutionPolicy", "Unrestricted", "REG_SZ"
Second this doesn't solve the problem.
The idea is to Bypass execution policy for this script... if we trust it, of course.
I do!
Now you can enjoy your CoreConfig

Abilitare un alias per un Fileserver Windows 2008 R2

2012-03-26T12:05:00.000+02:00

Problema (tipico delle operazioni di consolidamento):
abbiamo un server con nome Server1 che deve rispondere anche alle richieste con il nome Server2, quindi sia come \\Server1 che \\Server2.

Da Windows 2008 in avanti i computer oltre a supportare SMB 1.0 supportano anche SMB 2.0. SMB è il protocollo che che supporta sia lato client che lato server la "Condivisione File e stampanti".

Quindi per abilitare l'alias SERVER2 dobbiamo:
1) Creare un CNAME (Alias) nel DNS server2.miodominio.local che punti a server1.miodominio.local
2) Abilitare il supporto per l'aliasing per il protocollo SMB 1.0:
Apriamo l'Editor di Registro (regedit) ed posizioniamoci su
HKEY_LOCAL_MACHINE\System\CurrentControlSet\Services\LanmanServer\Parameters

Aggiungiamo una nuova REG_DWORD:

Nome Valore: DisableStrictNameChecking
Tipo di dati : REG_DWORD
Base : Decimale
Valore : 1
3) Facciamo un reboot del server per fargli prendere le modifiche
4) Creaiamo un Alias per l' SMB 2.0:
Apriamo un prompt dei comandi con privilegi amministrativi:
setspn -a host/server2 server1
(dove server2 è l'alias netbios e server1 è il nome netbios originale del nostro server)
setspn -a host/server2.miodomino.local server1
(dove server2.miodomino.local è il FQDN dell'alias che vogliamo creare e server1 è il nome netbios originale del nostro server)

Adesso provate ad aprire \\server2 e dovreste accedere alle condivisioni

Coesistenza di IIS ed Apache sulla porta 80

2012-02-20T12:35:00.001+01:00

La risposta più ovvia è che affiché i due servizi possano utlizzare la stessa porta bisogna metterli in ascolto su due IP diversi.
Quindi diciamo che vogliamo creare due endpoint:
1) APACHE: 192.168.1.1:80
2) IIS: 192.168.1.2:80

Per quanto riguarda Apache basta andare nell' httpd.conf e modificare la sezione:
LISTEN 80
in
LISTEN 192.168.1.1:80
(ovviamente controllando anche eventuali configurazioni al livello di singoli siti)
Si riavviano i servizi ed è tutto pronto.

Su IIS si va sui bindigs dei siti ed invece di selezionare tutti gli ip disponibili ossia 0.0.0.0 si seleziona esplicitamente l'IP 192.168.1.2.

E non va! :)

In effetti il nostro IIS si mette comunque in ascolto su 0.0.0.0:80 e quindi è in conflitto con l'incolpevole Apache.

Bisogna cambiare esplicitamente il listener HTTP.

Windows 2003 IIS6:
1) Scaricare httpcfg.exe dai support tool dal CD di installazione o da internet
2) Fermiamo i servizi IIS tramite il comando: net stop http /y
3) Fermare i servizi di Apache
4) Modifichiamo il listener: httpcfg set iplisten -i 192.168.1.2
5) Facciamo ripartire IIS: net start w3svc
6) Riavviamo Apache

Windows 2008 IIS7
Qui l'evoluzione del NETSH ci semplifica la vita
1) Apriamo un prompt dei comandi con privilegi amministrativi e diamo i seguenti comandi:
2) NETSH
3) HTTP
4) add iplisten ipaddress=192.168.0.2
5) EXIT

In ambedue i casi potete verificare tramite il comando:
NETSTAT -an
che il server è in ascolto correttamente su

192.168.1.1:80
192.168.1.2:80

Se trovate ancora 0.0.0.0:80
date il comando:
ISSRESET

Come fare: Backup Windows 2008 R2 Server Core

2012-01-31T11:33:00.001+01:00

Come fare un backup di un Server Core Windows 2008 R2 senza usare strumenti di terze parti, ma sfruttando il backup integrato di Windows?
1) Installiamo la funzionalità di backup:
start /w ocsetup WindowsServerBackup
2) Eseguiamo il backup da riga di comando:
wbadmin start backup -allCritical -backupTarget:"\\Nome_Server\Backup_Folder"

Per approfondimenti sul comando WBADMIN

SQL Server 2008 Data Collector

2012-01-23T01:05:00.004+01:00

Versione in italiano

Introduction

The typical problems of any DBA is to monitor the installation of its DB in terms of performance and server loads.
The process of preparing data collectors in order to do an analysis usually is a time-consuming and tricky task.
But if we are Database SQL Server 2008 lucky DBA, Microsoft has developed a tool that does the work for us: SQL data collector (not to be confused with Windows performace monitor Data Collector).
In this way, the data collectors become a powerful ally of all DBAs, especially those less experienced.
Architecture

Although the architecture is quite complex

Data Collector Architecture: source MSDN

Installation is very simple because the configuration and parameterization is minimal, however, the data collector was designed to have extremely low overhead on the system when collecting and analyzing data.
It creates SSIS Package (SQL Server Integration Service) launched by SQL Server Agent Jobs working to collect and store data in a Management Data WareHouse (from henceforth MDW ) and finally the information is shown through a series of dynamic reports linked to each other that allow us to analyze in detail our SQL Server instances activities and trends.

Installation

Open SSMS and go to the section of Management, right-click and select a data collector configuration data collectors

Then proceed with the MDW configuration

Choose where you want to create it and how to call it (I've imaginatively called it DataCollector).

CAUTION: The data warehouse DB can come to occupy up to 10GB of disk space!

So be careful where you position it and its initial and maximum size (if you want to set it)

Going forward we are asked to configure roles and permissions, but if you don't have any special need you can proceed without selecting anything. So you complete this first configuration phase

Again we return to the Configuration

And this time we choose to set the data collection

and simply select the previous data warehouse and choose a directory in which park the data collected before they are placed in the MDW (see below: Query and System collectors collect data with a high frequency, but uploading to the Data Wharehouse is deferred in ways to avoid too much overhead due a nearly continuous data entry)

Even here we can proceed and complete the configuration

At this time our collectors are finally activated and slowly begin to populate our MDW

Data Collectors

After configuring our SSIS packages and their jobs are ready and running, you'll see the collectors properties below that are shown only for explanatory purposes, those who were not interested in learning more can safely skip this paragraph.

How we can inferred in the previous images we have three types of collectors (4 in SQL 2008 R2):

Disk Usage
Query Statistics
Server Activity

Disk Usage: keeps track of Database and Log files growth collecting information from a series of system tables and views.
Sampling is done every 6 hours and is loaded simultaneously on the MDW (given the low frequency). The data is kept for 730 days so as to allow adequate delineation of the growth trends.

Query statistics: collects data on SQL statements and their execution plans sampling every 10 seconds some Dynamic Management Views ( from now DMV). MDW loading in this case is delayed and occurs every 15 minutes. Collected data is stored in the MDW for 14 days.

Server Activity: provides a view on the SQL Server activity, resources use and competition over resources, and also collects data on overall System resources allowing to identify any bottlenecks external respect than DB engine. In this case the data are collected by querying DMVs and SQL Sever and system performance counters.
Sampling occurs every 60 seconds and the data is uploaded every 15 minutes in the MDW where they are kept for 14 days.

As can be seen from the images is possible, but absolutely not necessary, change any parameter, such as data retention period in the MDW.

Reports

If you do not want to wait for the default schedules at any time you can force data collection and loading .

Collected data analysis will put a strain on even a very experienced DBA, and for this reason that the second, and perhaps the greatest, advantage of the Data Collector are available reports.

As you can see reports are related one to one with collectors.
So let's see how our data are available and their graphical representation.
I apologize for the fact that all pictures are taken from a test environment virtually stationary, where the only load is the Data Collector, but this must not lead to the error of thinking that the tool creates a strong overhead on monitored systems.
Disk Usage

Show all of our instance databases data and log files in terms of size and growth. Clicking on the name of the individual DB we can see free space and a list of all events related to their growth.

Query Statistics

First displays Queries Top 10 in relation to their resource consumption (default CPU) in a graphical format

and in textual form

Clicking on a single statement you can display details with valuable informations about resources use and the possibility of going into Waits details.

Server Activity:

This report displays the graphs for the four SQL tuning key resources. Very interesting is the fact that allows us to separate SQL Server from System activity.
It also puts in a graphical format, with the ability to go into detail with a single click, SQL Server Waits and the most significant activities in terms of SQL Server monitoring.

Conclusions and final notes

As we have seen this tool combines two great qualities: ease of configuration and power of analisys, so I'm sure that it will soon become part of almost all of your SQL Server installations.
Unfortunately, SQL Server 2005 does not support data collectors but MSSQLDUDE suggests us a technique to remedy the problem (to be honest I have never tried it)
Also remember that you can always export charts to PDF or Excel format.

Link:
Data Collector on MSDN
SQL Authority (where I stole some pictures)

Il Data Collector di SQL Server 2008

2012-01-22T19:03:00.009+01:00

English Version

Introduzione

Il tipico problema di ogni DBA è tenere sotto controllo le installazioni dei propri DB in termini di performance e carichi del server.
Il processo di preparazione di collettori di dati per poter fare analisi è normalmente un task laborioso e spinoso.
Ma se siamo dei fortunati DBA di Database SQL Server 2008, Microsoft ha predisposto uno strumento che fa il lavoro al nostro posto: i data collector per SQL (da non confondere con gli omonimi del performace monitor di Windows).
In questo modo i data collector diventano un potentissimo alleato di tutti i DBA, soprattutto di quelli meno esperti.

Architettura

Nonostante l'architettura sia abbastanza complessa

Architettura dei DATA Collector: fonte MSDN

l'installazione risulta essere molto semplice in quanto la configurazione e la parametrizzazione è minima, peraltro il data collector è stato disegnato per avere un overhead molto basso sul sistema in fase di raccolta ed analisi dei dati.
Crea dei pacchetti SSIS (SQL Server Integration Service), lanciati tramite dei JOB e quindi l'Agent di SQL Server, che si occupano di raccogliere e memorizzare i dati all'interno di un Data Ware House di gestione (Managemet Data WhareHouse da ora in poi MDW) ; infine rappresenta le informazioni raccolte tramite una serie di Report dinamici linkati tra di loro che ci consentono di analizzare a fondo l'attività ed i trend delle nostre istanze di SQL Server.

Installazione

Apriamo SSMS ed andiamo nella sezione di Gestione, tasto destro su data collector e selzioniamo configura data collector

poi procediamo con la configurazione del MDW:

Scegliamo dove crearlo e come chiamarlo (io con molta fantasia l'ho chiamato DataCollector).

ATTENZIONE: a regime il Data WhareHouse può arrivare ad occupare fino a 10GB di spazio disco!

Quindi fate attenzione a dove lo posizionate ed alle dimensioni iniziali, incrementiali e massime (se proprio dovete impostarle)

Andando avanti ci viene chiesto di configurare i ruoli e le autorizzazioni, ma se non avete esigenze particolari potete semplicemnte procedere senza selezionare nulla andando completare la prima fase di configurazione

Nuovamente torniamo sulla configurazione

E questa volta scegliamo di impostare la collezione dei dati

e semplicemente selezioniamo il Data Wharehouse creato precendentemente ed una directory in cui parcheggiare i dati raccolti prima che vengano inseriti nel MDW (come vedremo più avanti i collettori delle query e di sistema raccolgono dati con un'elevata frequenza, ma il caricamento nel DB di Data Wharehouse avviene in maniere differita per evitare un eccessivo overhead dovuto ad un quasi continuo inserimento di dati)

Anche qui possiamo procedere e completare la configurazione

A questo i nostri collettori sono finalmente attivati e pian piano il nostro MDW comincerà a popolarsi

I Data Collector

Finita la configurazione i nostri pacchetti SSIS ed i loro Job sono pronti e funzionanti; le proprietà dei collettori che vedrete di seguito sono visualizzate solo a scopo esplicativo, chi non fosse interessato ad approfondire può tranquillamente saltare questo paragrafo.

Come possiamo evincere nell'immagine precedente abbiamo tre tipologie di collettori (4 su SQL 2008 R2):

Utilizzo del disco
Statistiche sulle Query
Attività del Server

Utilizzo del disco: mantiene traccia della crescita dei file di Database e di Log raccogliendo informazioni da una serie di tabelle e viste di sistema.
Il campionamento avviene ogni 6 ore e viene simultaneamente caricato sul MDW (vista la bassa frequenza). I dati vengono mantenuti per 730 giorni in maniera da consentire un adeguato delineamento dei trend di crescita.

Statistiche sulle Query: raccoglie dati sugli statement SQL ed i relativi piani di esecuzione campionando alla frequenza di 10 secondi alcune viste di gestione dinamica ( Dynamic Management Views, da ora in poi DMV). Il caricamento in questo caso è differito ed avviene ogni 15 minuti. I dati vengono conservati nel MDW per 14 giorni.

Attività del Server: fornisce una visualizzazione sull'attività, l'utilizzo di risorse e la competizione sulle risorse di SQL Server, raccoglie inoltre dati generali sulle risorse di sistema per consetire l'identificazione di eventuali colli di bottiglia esterni rispetto al motore di DB. In questo caso i dati vengono raccolti sia dalle DMV che da molti contatori di performance di SQL Sever e di sistema.
Il campionamento avviene ogni 60 secondi ed i dati vengono caricati sul MDW ogni 15 minuti dove vengono conservati per 14 giorni.

Come si evince dalle immagini è possibile, ma assolutamente non necessario, modificare alcuni parametri, come ad esempio il periodo di di ritenzione dei dati nel MDW.

I Report

Se non avete voglia di aspettare le schedulazioni predefinite potete in qualsiasi momento forzare la raccolta ed il caricamento dei dati.

L'analisi dei dati raccolti mettere a dura prova anche un DBA di grande esperienza, e per questo motivo che il secondo, e forse anche il più grande, vantaggio del Data Collector sono i report che mette a disposizione.

Come vedete i report sono in rapporto uno ad uno con i collettori.
Vediamo quindi i dati che ci vengono messi a disposizione e la loro rappresentazione grafica.
Mi scuso per il fatto che tutte le immagini sono prese da un ambiente di test praticamente fermo, in cui l'unico carico è quello del Data Collector, ma questo non deve assolutamente indurre nell'errore di pensare che lo strumento crei un forte overhead sul sistema monitorato.

Utilizzo del disco

Visualizza tutti i file di Dati e Log dei Database della nostra istanza in termini di grandezza e crescita. Cliccando sul nome del singolo DB possiamo vedere lo spazio libero e l'elenco di tutti gli eventi correlati alla loro crescita.

Statistiche sulle Query

Innanzitutto visualizza la TOP 10 delle Query relativamente al consumo di risorse (di default la CPU) in formato grafico

ed in forma testuale

Cliccando poi sul singolo statement si entra in una visualizzazione di dettaglio con preziosissime informazioni inerenti le risorse utilizzate e la possbilità di entrare nel dettaglio dei waits

Attività del Server:

questo report consente di visualizzare dei grafici relativi alle quattro risorse fondamentali in fase di tuning di SQL. Molto interessante è il fatto che ci consente di separare l'attività SQL Server da quella di Sistema.

Inoltre mette in formato grafico, con la possibilità di entrare nel dettaglio tramite un semplice click sia i Wait che le attività più significative in termini di performance tuning del server SQL.

Conclusioni e note finali

Come abbiamo visto questo strumento coniuga due grandi qualità: semplicità di configurazione e potenza di analisi, quindi sono certo che diventerà presto parte di quasi tutte le vostre installazioni di SQL Server.
Purtroppo SQL Server 2005 non supporta i data collector ma MSSQLDUDE suggerisce una tecnica per ovviare al problema (ad onor del vero non l'ho mai provata).
Inoltre ricordate che potete sempre esportare i grafici in formato PDF o Excel.

Link:
Data Collector su MSDN
SQL Authority (a cui ho rubato un pò di immagini)

Trucco: CmdKey

2012-01-17T15:35:00.000+01:00

Le connessioni verso un client o server che richiedono autenticazione hanno necessità di creare un contesto di autorizzazione.
Tipicamente ci viene richiesto di inserire Utente e Password, le credenziali immesse vengono memorizzate sul computer locale e riutilizzate automaticamente quando ci si connette nuovamente al compuer remoto.
Come gestire questo archivio?
Tramite l'utility a riga di comando cmdkey.exe.
Esempi:
cmdkey /list -- fa una lista delle credenziali memorizzate

cmdkey /add:server01 /user:mikedan -- usa l'utente mikedan per connetersi al server01

cmdkey /delete:server01 -- elimina le credenziali per connettersi al server01

http://technet.microsoft.com/en-us/library/cc754243(WS.10).aspx

Trucco: ReadyBoost

2011-11-02T20:23:00.001+01:00

Hai poca RAM e sul computer rallenta tutto?
Window Vista e Windows 7 offrono un'interessante funzionalità. ReadyBoost, che consente di espandere la RAM su di una memoria Flash.
La maggior parte dei dispositivi di Flash, quindi le varie schedine SD ed i pennini USB sono compatibili. Nonostante il transfer rate di questi dispositivi sono normalmente inferiori a quelli degli HD, i tempi di accesso sono enormemente inferiori. Quindi per le letture non sequenziali di dati brevi il sistema cerca di usare l'unità flash, nell'altro caso preferisce utilizzare l'HD che è più performante.
L'attivazione di può avvenire o tramite il menù dell'autoplay o tramite proprietà del dispositivo rimovibile.

Il sistema non utilizzerà banalmente l'unità per il file di swap, ma ci sposterà files frequentemente acceduti e file di boot.
Nei computer portatili questa funzionalità di caching può fare diminuire gli accessi all'HD permettendo ai dischi di andare in standby ed aumentando quindi la durata della carica delle batterie.
Con sistemi dotati di 512mb di RAM le performaces possono migliore incredibilmente, all'aumentare della quantità di RAM i benefici tendono a scomparire.

Su Windows XP nativamente non è disponibile questa funzionalità, ma la società russa Moscow Development Office ha sviluppato il programma eBoostr in grado di emulare il sistema Readyboost, rendendolo compatibile anche con dispositivi Firewire e eSata.

Microsoft Events

2011-10-19T20:47:00.004+02:00

In cerca di documentazione e possibilità di provare tecnologie Microsoft?
Magari senza perdere tempo a scaricare ed installare Software?

Su Microsoft Word Wide Events avete la possbilità di trovare webcast su le principali teconlogie e, cosa molto interessante, fruire gratuitamente di Virtual Labs, ossia ambienti virtuali corredati di istruzioni per provare ed imparare.

Come potete vedere basta selezionare come tipo di evento Virtual Labs e nel mio caso ho filtrato per Technet (c'è anche parecchio materiale relativo ad MSDN), ma è ovviamente possibile fare ricerche per tecnologie specifiche.

Una volta trovato il laboratario virtuale che vi interessa seguite le istruzioni.
E' necessario un LiveID per poter accedere al laboratorio, ma se non lo avete potete traquillamente crearlo in fase di accesso.

Buon divertimento!

Steve Jobs

2011-10-06T11:47:00.000+02:00

"Il tuo tempo è limitato, perciò non sprecarlo vivendo la vita di qualcun altro. Non lasciarti intrappolare dai dogmi - che significa vivere i risultati del pensiero di altre persone. Non lasciare che il rumore delle opinioni altrui offuschi la tua voce interiore.
E, cosa più importante, abbi il coraggio di seguire il tuo cuore ed il tuo intuito. Loro in qualche modo già sanno cosa vuoi davvero diventare. Tutto il resto è secondario" Steve Jobs

A prescindere da simpatie e preferenze personali è morto uno dei più grandi innovatori dell' era informatica.

Trucco: Windows 7 GodMode

2011-06-28T12:25:00.001+02:00

Vuoi il controllo totale sul tuo PC Windows 7?
Attiva la modalità "divina" ed accedi al menù segreto.

Crea una nuova cartella sul desktop e chiamala:
GodMode.{ED7BA470-8E54-465E-825C-99712043E01C}

Apri la cartella ed eccoti tutte le opzioni di configurazione di Windows 7!

Se non ti serve più basta cancellare la cartella.

TSQL: Funzione di Levenshtein per analizzare la similitudine fra stringhe

2011-05-05T20:03:00.004+02:00

La distanza tra due parole, secondo l'algoritmo di Levenshtein non è altro che il grado di similitudine tra queste due parole, viene di fatto calcolata la somiglianza tra parole. A volte si ha a che fare con dati sporchi digitati non correttamente su diverse tabelle proveniente da diversi ambiente ed è difficile riconciliare le informazioni usando solo query con la condizione LIKE.

La funzione che segue, scritta in TSQL per SQL server, ci viene incontro, basandosi sull'algoritmo di Levenshtein, restituisce un numero intero che rappresenta la distanza, ovvero la differenza, tra le due parole. Più il risultato è basso più le parole sono simili, nel caso di due parole uguali l'algortimo restituisce 0.

L'algoritmo di Levenshtein di fatto restituisce il numero minimo di modifiche da applicare alla parola A per trasformarla in un altra B, dove per modifica si intende: la cancellazione di un carattere, la sostituzione di un carattere con un altro, o l'inserimento di un carattere.

create function dbo.Levenshtein (@parola1 varchar(30), @parola2 varchar(30))
returns int
as
begin
 declare @distanza int -- La variabile che viene restituita
 declare @lenparola1 int -- La lunghezza della prima parola
 declare @lenparola2 int -- la lunghezza della seconda parola

 -- Calcolo la lunghezza delle due parole

 set @lenparola1 = len(@parola1)
 set @lenparola2 = len(@parola2)
 
 -- Se la lunghezza di una delle due parole è 0 allora viene restituita la lunghezza dell'altra
 if @lenparola1 = 0
  set @distanza = @lenparola2
 else if @lenparola2 = 0
  set @distanza = @lenparola1
 else
  begin
  declare @array_temp table (riga int,colonna int,valore int)
  -- Creo una tabella temporanea per simulare un array bidimensionale
  declare @i int
  declare @j int
  
  -- inizializzo la cella (0,0) con il valore 0
  insert @array_temp values (0, 0, 0)

  -- importo i valori della prima riga e della prima colonna a 0
  set @i = 1
  while @i <= @lenparola1
   begin
   insert @array_temp values (@i, 0, @i)
   set @i = @i + 1
   end
  set @j = 1
  while @j <= @lenparola2
   begin
   insert @array_temp values (0, @j, @j)
   set @j = @j + 1
   end
 
  -- Ciclo sulle due parole calcolando la distanza
 
  declare @cost int
  declare @min1 int
  declare @min2 int
  declare @min3 int
 
  set @i = 1
  while @i <= @lenparola1
   begin
   set @j = 1
   while @j <= @lenparola2
    begin
    -- Compara i caratteri e determina il @cost
    -- Se sono uguali @cost = 0.

-- Se diversi @cost = 1
    
    if (substring(@parola1, @i, 1) = substring(@parola2, @j, 1))
     set @cost = 0
    else
     set @cost = 1
    
    -- Calcolo il minimo tra:
    -- La cella a sinistra
    -- Quella in alto
    -- E quella in alto a sinistra in diagonale
    
    select @min1 = [valore] + 1
    from @array_temp
    where riga = @i - 1 and colonna = @j
    
    select @min2 = [valore] + 1
    from @array_temp
    where riga = @i and colonna = @j - 1
    
    select @min3 = [valore] + @cost
    from @array_temp
    where riga = @i - 1 and colonna = @j - 1
    
    if @min2 < @min1
    set @min1 = @min2
    if @min3 < @min1
    set @min1 = @min3
    
    insert into @array_temp values (@i, @j, @min1)
    set @j = @j + 1
    end
   set @i = @i + 1
   end
  -- La distanza finale è la cella in basso a destra
  select @distanza = [valore]
  from @array_temp
  where riga = @lenparola1 and colonna = @lenparola2
  end
 -- Restituisco la distanza
 return @distanza
end

Possiamo ad esempio utilizzarla:

select * 
from miatabella 
where dbo.Levenshtein ('paroladaconfrontare', miatabella.miocampo) < 3

N.B.: Questa funzione è stata presa in rete e non scritta da me

P.S. la versione Enterprise di SQL Server 2008 R2 comprende i

 Master Data services

che includono questa ed altre funzioni di Fuzzy lookup.

Gli Snapshot in ambito Microsoft Windows Hyper-V

2011-03-15T22:43:00.002+01:00

Una delle cose che affascina molto nei progetti di virtualizzazione è la possibilità di creare delle fotografie (snapshot) delle macchine virtuali.
Questa funzionalità, apparentemente semplice, nasconde non poche insidie e viene spesso fraintesa.
Da questo nasce l'idea di questo articolo il cui obiettivo è di fare maggiore chiarezza sull'argomento.
Se vi annoiano i discorsi troppo tecnici e vi interessa solo il succo potete saltare direttamente alle conclusioni nel paragrafo finale: Avvertenze sugli snapshot.

Introduzione Terminologica

VHD
Un Disco Fisso Virtuale è un file fornisce spazio disco ad una macchina virtuale (e non solo).
All'interno della macchina virtuale è visto e trattato come un normale disco fisico.

Disco Differenziale
Un disco differenziale virtuale è un un disco fisso virtuale associato ad un altro disco fisso virtuale in una realazione di titpo padre-figlio.
Il disco differenziale (figlio) memorizza tutte le modifiche fatte sul disco padre, consentendone quindi il salvataggio senza che alcuna modifica sia effettivamente eseguita sul disco padre. In altre parole, utilizzando i dischi differenziali, ci assicuriamo che le modifiche siano riportate sul disco differenziale e non sul disco vhd originale.
Successivamente è possibile, se lo desideriamo, unire il disco differenziale con il disco padre al fine di avere un solo VHD contenente tutte le modifiche.

Gli Snapshot

Gli Snapshot sono una funzionalità dell' Hyper-V di Windows Server 2008 R2 che ci consente di creare una versione ad un determinato momento della nostra macchina virtuale.
Il vantaggio dal punto di vista amministrativo e che ci consentono di create gerarchie di modifiche e di poter tornare facilmente indietro.
Gli snapshot non apportano alcuna modifica allo stato delle macchine virtuali cui fanno riferimento.

Come Funzionano

Hyper-V segue i seguenti passi per la creazione di uno snapshot:

Mette in pausa la maccina virtuale
Crea un disco differenziale per ogni vhd configurato sulla macchina virtuale
Fa una copia del file di configurazione della macchina virtuale
Fa ripartire la macchina virtuale
Se la macchina era in esecuzione viene salvato il contenuto della memoria sui nuovi dischi differenziali

Tutte queste operazioni si svolgono in maniera trasparente per gli utenti che non dovrebbero riscontrare alcun rallentamento o indisponibilità della macchina virtuale. In pratica la macchina durante la sua fase di pausa trattiene in memoria tutte le modifiche effettuate, per salvarle nel passo 5.

I file degli snapshot

Uno snapshot consiste di diversi file che vengono memorizzati in una directory degli snapshot associata alla macchina virtuale.
Nel dettaglio avremmo:

Un file di configurazione della macchina virtuale (.xml)
Dischi differenziali dello snapshot (.avhd)

Nel caso in cui la macchina virtuale al momento dello snapshot era attiva o salvata:

File di salvataggio di stato della macchina virtuale (.vsv)
Contenuto della memoria (.bin)

Non operate mai direttamente sui file degli snapshot! ( a meno che non sappiate esattamente cosa state facendo)

Azioni possibili sugli snapshot

Tramite lo snap-in di gestione di Hyper-V, ed in buona parte anche tramite SCVMM (System Center Virtual Machine Manager) che li chiama però Checkpoint, è possibile eseguire le seguenti azioni relaitve agli snapshot delle macchine virtuali:

Creare uno nuovo
Rinominare
Applicare (SCVMM:Ripristinare) uno snapshot, ossia riportare la macchina virtuale allo stato dello snapshot.
Cancellare uno snapshot: se lo snapshot non è quello corrente viene semplicemente cancellato, se invece è quello attivo tutte le modifiche verranno riportate (merge) sul VHD originale al momento dello spegnimento della macchina virtuale. Attenzione questa operazione può portare via parecchio tempo in fase di riavvio!

Gestione tramite Hyper-V

Gestione tramite SCVMM

Avvertenze sugli snapshot

A questo punto possediamo elementi sufficienti per trarre alcune importantissime conclusioni:

Evitate di usare gli Snapshot in ambienti di produzione. Si potrebbero avere seri problemi con servizi ed applicazioni sensibili ai tempi di risposta, tipo l'autenticazione di Active Directory, o che usano meccanismi di replica tipo Exchange ed SQL Server.
Gli snapshot possono consumare molto velocemente lo spazio disco, soprattuto se abbiamo più snapshot della stessa macchina virtuale.
Fate attenzione alle conseguenze della cancellazione degli snapshot.
Non considerate assolutamente gli snapshot un'alternativa al backup.

L'utilizzo degli snapshot che la Microsoft consiglia è per ambienti di test o di formazione.