Practicas Comunes

Book Review: Pro SQL Server 2008 Failover Clustering

2010-02-26T20:01:00.001-06:00

Pro SQL Server 2008 Failover Clustering, by Alan Hirt is over 370 pages about installing, configuring and tuning your SQL Server 2008 failover cluster. This book is a must read for everyone interested in migrating SQL 2005 in a failover cluster to SQL 2008 on Windows 2008 or anyone who just want to know some basic aspects about clustering in Windows 2008, some concepts also work for SQL 2005.

The book cover the following topics:

Failover Clustering Basics
Preparing to Cluster Windows
Clustering Windows Server 2008 Part 1: Preparing Windows
Clustering Windows Server 2008 Part 2: Clustering Windows
Preparing to Cluster SQL Server 2008
Installing a New SQL Server 2008 Failover Clustering Instance
Upgrading to SQL Server 2008 Failover Clustering
Administering a SQL Server 2008 Failover Cluster
Virtualization and Failover Clustering.

I’m right now following chapter by chapter the entire book to configure my SQL Server 2008 on my Windows 2008 cluster. What I liked the most about this book is that it teachs you how to configure anything using GUI, commands and PowerShell.

Failover Clustering Basics:

This chapter talks about some very basic aspects of clustering, before you actually even touch the server, the things you must know.

Preparing to Cluster Windows
This chapter starts explaining the concepts about clustering in Windows 2008, how to create them, quorum configuration, about the changes about the account that runs the cluster.

Clustering Windows Server 2008 Part 1: Preparing Windows

This chapter talks about networking (I think I should have talked about disabling TCP Offload, RSS, TCPA, etc), windows 2008 features to enable and expand more about the special account that runs the cluster.

Clustering Windows Server 2008 Part 2: Clustering Windows

It explains about the validations you should run in your cluster, before installing anything, quorum configurations.

Preparing to Cluster SQL Server 2008

This chapter starts talking about SQL 2008, what is clusterable and what not and some considerations you should be aware and what they entail.

Installing a New SQL Server 2008 Failover Clustering Instance

This chapter talks about the installation steps in SQL 2008, it guides step by step toward the end and it is very useful, you can follow easily these steps and configure your cluster in minutes.

Upgrading to SQL Server 2008 Failover Clustering

This talks about some considerations you should be aware if you are migrating from SQL 2000 or SQL 2005, very helpful, there other books that covers this more deeply though.

Administering a SQL Server 2008 Failover Cluster

This chapter talks about some related things you may be into, after you have your cluster up and running, like adding disks, nodes, changing ips, etc

To sum up, I deeply recommend this book to anyone involved in installing and migrating SQL servers to SQL 2008

Obteniendo las tablas con mas registros.

2009-08-20T16:19:00.001-05:00

Que tal,

Recientemente estaba tratando de ver las tablas que mas consumían espacio en todas las bases de datos, encontré un script en un blog que mostraba el total de registros en la base de datos, pero yo quería que fuera para todas las bases de datos.

Así que le hice unos pequeños cambios para que funcionara con todas las bases de datos.

Les comparto el script, esta probado en SQL 2005 aunque debería funcionar en SQL 2008.

El script no hace un count(*) a todas las tablas, sino que va directamente a las tablas de sistema:

SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
CREATE PROCEDURE [dbo].[BPSQL_Select_big_tables]
AS
BEGIN
SET NOCOUNT ON;

DECLARE @dbname2 varchar(40);
declare @id varchar(30);

DECLARE dbname CURSOR FOR select name,database_id from master.sys.databases where database_id>4

create table #tablas(
base_de_datos varchar(128),
tabla varchar(128),
total int
)

OPEN dbname
FETCH NEXT FROM dbname
INTO @dbname2,@id

WHILE @@FETCH_STATUS = 0
BEGIN

exec('SET NOCOUNT ON
use [' + @dbname2 + ']
insert #tablas

SELECT b.name,OBJECT_NAME(object_id) AS [Table Name], SUM(Rows) AS [Row Count]
FROM sys.partitions,sys.databases b
WHERE index_id < 2
and OBJECT_NAME(object_id) not like ''%sys%'' and OBJECT_NAME(object_id) not like ''%queue%''
and OBJECT_NAME(object_id) <> ''dtproperties'' and b.database_id='+@id+'
GROUP BY object_id,b.name
ORDER BY SUM(Rows) DESC')

FETCH NEXT FROM dbname INTO @dbname2,@id
END

CLOSE dbname
DEALLOCATE dbname

select top 100 *
from #tablas
order by 3 desc
drop table #tablas

END

Revisando si existen permisos directos a los usuarios.

2009-07-28T15:19:00.002-05:00

Una de las best practices en la administración de bases de datos, es asignar los permisos solo a los roles y no a los users o grupos, esto hace que las migraciones, planes de DRP, etc sean más sencillas.

Una de las formas de asegurar que se cumple con esta política en SQL 2005 es correr un script que indique si existen permisos directos a los users o grupos, en lugar de los roles.

Les comparto un script que hice, en el que se revisan en todas las bases de datos del servidor si se asignaron permisos directos, en caso de ser así, regresará la base de datos, el user, el tipo de permiso y la tabla, SP, etc.

Espero les sirva, yo lo corro diariamente en todos los servidores.

/* Revisa si existen usarios que tengan permisos directos en cada base de datos */
DECLARE @dbname2 varchar(40);
declare @id varchar(30);

DECLARE dbname CURSOR FOR select name,database_id from master.sys.databases;

CREATE TABLE #Permisos_Users(
[base_de_datos] [varchar](128) NULL,
[usuario] [varchar](128) NULL,
[tipo_permiso] [varchar](128) NULL,
[objeto] [varchar](128) NULL
)

OPEN dbname
FETCH NEXT FROM dbname
INTO @dbname2,@id

WHILE @@FETCH_STATUS = 0
BEGIN
exec('SET NOCOUNT ON;
use [' + @dbname2 + ']
INSERT #Permisos_Users
select d.name,b.name,a.permission_name,c.name from sys.database_permissions a inner join sys.database_principals b on a.grantee_principal_id=b.principal_id
inner join sys.objects c on a.major_id=c.object_id,sys.databases d where b.type_desc in (''SQL_USER'',''WINDOWS_USER'',''WINDOWS_GROUP'') and b.default_schema_name is not null
and b.name <> ''dbo'' and b.name <> ''guest'' and a.permission_name <> ''CONNECT'' and convert(varchar,d.database_id)='+@id+'')

FETCH NEXT FROM dbname INTO @dbname2,@id
END

CLOSE dbname
DEALLOCATE dbname

select * from #Permisos_Users

drop table #Permisos_Users

Planes de mantenimiento en SQL

2009-07-17T19:56:00.003-05:00

Muchas veces me he topado, que en diferentes empresas tienen planes de mantenimiento de SQL en el que, por ejemplo, una vez a la semana hacen un reorganize, rebuild y despues un "Update Statistics" a todas las bases de datos operativas.

Lo he visto configurado así y me sorprendo que así lo tengan, es común verlo en las que el DBA está por accidente.

Este tipo de mantenimientos no deberían de estar al mismo tiempo, ya que es redundante, es un desperdicio de recursos y en ocasiones hasta puede salir contraproducente.

Lo que idealmente debería pasar es estar monitoreando el nivel de fragmentacion de los indices, si los indices tienen menos de un 30% de fragmentacion, entonces aplicaría un reorganize y si es mas alto entonces un rebuild, un rebuild es mucho mas costoso en performance pero es más efectivo, si se tiene la versión Enterprise de SQL 2005, se puede hacer Online y de esta manera no se afecta a los usuarios, excepto aquellas tablas que tengan columnas LOB, idealmente se debería hacer sobre demanda en las tablas que lo necesiten.

Esto es idealmente, si tienes una base de datos en las que se hacen muchos cambios (INSERT, DELETE, UPDATE) entonces lo recomendable es que se haga solamente un rebuild, en el momento mas oportuno, cuando no afecte la operación, si tienes la versión Enterprise de SQL 2005/2008 entonces se puede hacer Online.

Tambien se podría hacer un reorganize O un update statistics diario y aunque no son tan efectivos como el rebuild tambien ayudan a mejorar el performance y no tienen afectación a los usuarios.

Voy a estar compartiendo mas informacion sobre este tema más adelante.

Apuntes sobre Tomcat en Windows.

2009-07-17T19:53:00.002-05:00

Recientemente estuve trabajando con Tomcat corriendo sobre Windows y después de estar trabajando con el por unos días tengo algunos tips que les pueden ser útiles.

Las versiones que utilizé fueron Tomcat 6.0.16 con Java 6 Update 7, pero podrían aplicar sobre otras versiones.

Aqui van algunos tips:

En el server.xml modificar la parte de logueo, ya que por default está deshabilitado y configurarlo para que no haga un resolve:

Valve className="org.apache.catalina.valves.AccessLogValve" directory="logs" prefix="localhost_access_log." suffix=".txt" pattern="combined" resolveHosts="false"

Si se van a tener contextos en los que constantemente se van a estar actualizando las aplicaciones, en produccion, por ejemplo, entonces hay que cambiar el archivo context.xml con las opciones antiResourceLocking="true" antiJARLocking="true" reloadable="true", modificarlo de:

Context

a

Context path="" antiResourceLocking="true" antiJARLocking="true" reloadable="true" cachingAllowed="false"

Al hacer esto todas las aplicaciones se copiarán al folder temp y desde ahí se van a servir y automaticamente se hara un deploy en caso de ser necesario. Esto es necesario porque en Windows los archivos se queden "lockeados" y las aplicaciones no se "recargan" completamente.

Si se configura de esta manera y tambien se tienen archivos estáticos, hay que configurar el contexto en el server.xml para excluirlo, de otra manera el contenido nuevo nunca se va a mostrar (a menos que se esté reiniciando el servicio de Tomcat).

Así quedaría:

Context path="/mifolder" antiResourceLocking="false" antiJARLocking="false" reloadable="false" override="true"

Tambien es recomendable configurar la memoria RAM que puede utilizar el tomcat, desde el archivo tomcatw.exe (en el folder bin), aquí se puede configurar la RAM mínima y máxima que puede utilizar el Tomcat.

Espero les sirvan estos tips.

Clonando servidores a través de los discos.

2009-06-26T19:32:00.003-05:00

Que tal,

Tal vez alguna vez han estado en una situación en la que se necesita "clonar servidores", pero no se tiene una herramienta como Altiris, Ghost, etc, si los servidores son del mismo modelo, mismos discos (velocidad, capacidad, etc) y misma tarjeta controladora PERC es posible hacer un clonado de los discos sin instalar nada y se tienen servidores identicos.

Esto lo acabo de hacer con servidores Dell con RAID 1, controladora PERC, 2 discos en espejo.

Aqui van los pasos:

1. Sacar del dominio (en caso de estar en alguno) al servidor, de preferencia tener instalado el OpenManage Server Administrator.
2. Apagar el servidor y sacarle uno de los discos.
3. Al nuevo servidor apagarlo tambien y sacarle uno de los discos, de preferencia del mismo lado.
4. Encender el equipo y entrar a la controladora de la PERC (Ctrl+M), navegar en la configuracion hasta la parte donde vienen los discos duros y marcar el disco original (no el que le acabamos de poner) como offline, lo que hará esto, es marcar el disco como degradado y ya no lo tomará en cuenta para bootear ni nada.
5. Reiniciar el equipo, al iniciar entrar al Server Administrator, navegar hasta el disco marcado como degradado y forzar un rebuild, con esto se empezará a reconstruir el disco que ya tenia el servidor con la nueva información.
6. Ahora, con el disco que habiamos sacado del servidor, meterselo de nuevo al servidor y hacer el mismo procedimiento, encender el servidor, entrar a la controladora, marcar el disco que acabamos de poner como degragado y encender el equipo.
7. Entrar al OpenManage Server Administrator y forzar un rebuild.

Con esto se tienen 2 servidores iguales, sin hacer nada de configuracion, puede sonar un poco complicado y riesgoso, pero es muy efectivo.

Getting the file share resources properties from a Windows 2003 cluster.

2009-06-19T15:42:00.003-05:00

Recently I was asked to do a script that generate a script to recreate all the file share resources from a Windows 2003.

I'm sharing the script I did, I'm using PowerShell, to run it needs the cluster name to connect to, then via WMI will get all the shares and using the tool cluster.exe (Available if you have the Administrative Tools) will get all the resource properties.

I run it every day in all my clusters, it creates a folder with the day it run, so you can run it everyday and have all the historical changes.

# Process to generate the script to re-create the file share resources from a Windows 2003 cluster.
# It needs the cluster name as a parameter and it generates the script with the configuration from each resource.
# The new cluster name will be NEWCLUSTER so you need to change it before run it.

param([string]$ServerOp) # Cluster Server Name.
$mydate = get-date -uformat "%Y%m%d"
$FolderScripts = "d:\DRCluster\scripts\$mydate\" # It will create this folder, so we have a folder by date.
$FileLog="d:\DRCluster\logs\DrCluster_$mydate.log" # Log File Name

clear-host
if (!$ServerOp){ throw "You must specify the cluster name" }

$f = [System.IO.Path]::Combine($FolderScripts, $ServerOp + "_shares.txt")
[string]$hora=get-date -uformat "[%r]"
out-file -filepath $FileLog -inputobject "#############################################################################################################################################" -append
out-file -filepath $FileLog -inputobject " " -append
out-file -filepath $FileLog -inputobject " PROCESS TO GENERATE THE SCRIPT TO RECREATE THE CLUSTER: $hora " -append
out-file -filepath $FileLog -inputobject " " -append
out-file -filepath $FileLog -inputobject "#############################################################################################################################################" -append
out-file -filepath $FileLog -inputobject " " -append

[string]$hora=get-date -uformat "[%r]"
if (!(Test-Path $FolderScripts)) {
out-file -filepath $FileLog -inputobject "$hora The folder $FolderScripts is created" -append
md $FolderScripts | Out-Null
if($? -ne $True) {
out-file -filepath $FileLog -inputobject "$hora ERROR: Couldn't create the folder: $FolderScripts" -append
throw "The folder $FolderScripts could not be created"
}
}

$f = [System.IO.Path]::Combine($FolderScripts, $ServerOp + "_shares.txt")
out-file -filePath $f -inputobject "REM ######################################################################################################## " -Encoding ASCII
out-file -filePath $f -inputobject "REM SCRIPT TO RECREATE THE SHARES IN ANOTHER CLUSTER" -Append -Encoding ASCII
out-file -filePath $f -inputobject "REM VERIFY DRIVES AND CLUSTER NAME BEFORE RUN IT! " -Append -Encoding ASCII
out-file -filePath $f -inputobject "REM ######################################################################################################## " -Append -Encoding ASCII
out-file -filePath $f -inputobject " " -Append -Encoding ASCII
out-file -filePath $f -inputobject " " -Append -Encoding ASCII

[string]$hora=get-date -uformat "[%r]"
out-file -filepath $FileLog -inputobject "$hora Getting the shares..." -append
$shares = Get-WMIObject Win32_Share -Computer $ServerOp
if($? -ne $True) {
out-file -filepath $FileLog -inputobject "$hora ERROR: There was an error getting the shares" -append
break
}else{
[string]$hora=get-date -uformat "[%r]"
out-file -filepath $FileLog -inputobject "$hora Done.." -append
}
out-file -filepath $FileLog -inputobject " " -append
[string]$hora=get-date -uformat "[%r]"
out-file -filepath $FileLog -inputobject "$hora Begin processing every share to get the configuration" -append
foreach ($sharefolder in $shares){
if (0 -eq $sharefolder.Type){

$Groups = Get-WmiObject -class MSCluster_ResourceGroupToResource -namespace "root\mscluster" -computername $ServerOp
$name=$sharefolder.Name

$Group = $Groups | Where-Object { $_.PartComponent -eq "MSCluster_Resource.Name="""+$name+"""" }
if ($Group -ne $null){
[string]$mygrp = $Group.GroupComponent
$Groupshare = $mygrp.Substring($mygrp.IndexOf(""""),$mygrp.Length-$mygrp.IndexOf(""""))
[string]$mystring="cluster /cluster:NEWCLUSTER resource "+"""$name"""+ " /create /group:"+$Groupshare+ " /type:""File Share"""
out-file -filepath $f -inputobject $mystring -append -Encoding ASCII
[string]$mystring="cluster /cluster:NEWCLUSTER resource "+"""$name"""+ " /priv path="""+$sharefolder.Path+""""
out-file -filepath $f -inputobject $mystring -append -Encoding ASCII
[string]$mystring="cluster /cluster:NEWCLUSTER resource "+"""$name"""+ " /priv Sharename="+$sharefolder.name
out-file -filepath $f -inputobject $mystring -append -Encoding ASCII
[string]$mystring="cluster /cluster:NEWCLUSTER resource "+"""$name"""+ " /priv Remark="""+$sharefolder.Description+""""
out-file -filepath $f -inputobject $mystring -append -Encoding ASCII
[string]$mystring="cluster /cluster:NEWCLUSTER resource "+"""$name"""+ " /prop Description="""+$sharefolder.Description+""""
out-file -filepath $f -inputobject $mystring -append -Encoding ASCII

$Access = @();
$SD = (Get-WMIObject -Class Win32_LogicalShareSecuritySetting -Computer $ServerOp -Filter "Name='$($name)'").GetSecurityDescriptor().Descriptor
$SD.DACL | %{ $Trustee = $_.Trustee.Name
If ($_.Trustee.Domain -ne $Null) { # The account has a domain.
$Trustee = "$($_.Trustee.Domain)\$Trustee"
$Access+= New-Object System.Security.AccessControl.FileSystemAccessRule($Trustee, $_.AccessMask, $_.AceType)
} elseif ( $_.Trustee.Name -ne $Null ) { # The account doesn't have a domain, but still valid, e.g. Everyone
$Access+= New-Object System.Security.AccessControl.FileSystemAccessRule($Trustee, $_.AccessMask, $_.AceType)
}else{ # The account doesn't have a domain nor valid.
Write-Host "Warning: Found an account in the share that could not be resolved, its possible that doesnt exists in AD"
$sharetemp1 = $sharefolder.Name
out-file -filepath $FileLog -inputobject "Found an account in the share that could not be resolved, its possible that doesnt exists in AD" -append
}
}
foreach($permission in $Access){
if ( $permission.FileSystemRights -eq "ReadAndExecute,Synchronize"){ $perm = "R" }
elseif ( $permission.FileSystemRights -eq "Modify,Synchronize"){ $perm ="RC" }
elseif ( $permission.FileSystemRights -eq "FullControl") { $perm = "F" }
if ($permission.AccessControlType -eq "Allow") {
[string]$mystring="cluster /cluster:NEWCLUSTER resource "+"""$name"""+ " /priv Security="""+$permission.IdentityReference+""""+",grant,"+$perm+":security"
out-file -filepath $f -inputobject $mystring -append -Encoding ASCII
}
}
$cmd = cluster.exe $ServerOp res $name /listdep | select-string "Online"
if($? -ne $True) {
out-file -filepath $FileLog -inputobject "$hora ERROR: THERE WAS AN ERROR GETTING THE DEPENDENCIES" -append
}
$gtp = " " + $Groupshare.substring(1,$Groupshare.length-2) + " "
foreach ($myline in $cmd){
[string]$valor=$myline;
$dep=($valor.substring(0,$valor.indexOf($gtp,$gtp.length-1))).trimend()
[string]$mystring="cluster /cluster:NEWCLUSTER resource "+"""$name"""+ " /AddDep:"""+$dep+""""
out-file -filepath $f -inputobject $mystring -append -Encoding ASCII
}

[string]$mystring="cluster /cluster:NEWCLUSTER resource "+"""$name"""+ " /On"
out-file -filepath $f -inputobject $mystring -append -Encoding ASCII
out-file -filepath $f -inputobject " " -append -Encoding ASCII
}
}
}
[string]$hora=get-date -uformat "[%r]"
out-file -filepath $FileLog -inputobject "$hora Done getting the shares properties" -append
out-file -filePath $FileLog -inputobject " " -Append

out-file -filepath $FileLog -inputobject "#############################################################################################################################################" -append
out-file -filepath $FileLog -inputobject " " -append
out-file -filepath $FileLog -inputobject " END OF THE PROCESS: $hora " -append
out-file -filepath $FileLog -inputobject " " -append
out-file -filepath $FileLog -inputobject "#############################################################################################################################################" -append

This will generate a file that will look like this:
cluster /cluster:NEWCLUSTER resource "Backup" /create /group:"mygroup" /type:"File Share"
cluster /cluster:NEWCLUSTER resource "Backup" /priv path="t:\mypath"
cluster /cluster:NEWCLUSTER resource "Backup" /priv Sharename=MYSHARE
cluster /cluster:NEWCLUSTER resource "Backup" /priv Remark="comments of my share"
cluster /cluster:NEWCLUSTER resource "Backup" /prop Description="comments of my share"
cluster /cluster:NEWCLUSTER resource "Backup" /priv Security="BUILTIN\Administrators",grant,F:security
cluster /cluster:NEWCLUSTER resource "Backup" /priv Security="MYDOMAIN\MYGROUP",grant,F:security
cluster /cluster:NEWCLUSTER resource "Backup" /priv Security="MYDOMAIN\MYACCOUNT",grant,F:security

Revisar permisos directos en SQL.

2009-06-19T14:43:00.002-05:00

Es muy frecuente que se establezca como política (o como un Best Practice) que los permisos a los objetos de una base de datos se den solamente a roles y no a usuarios.

Esto es muy importante, es mucho mas recomendable asignar permisos a través de roles que a usuarios, de tal manera, que en caso de migrar una base de datos a un servidor diferente, solamente se tengan que recrear los usuarios, y no recrear los usuarios y tener que volver a asignar permisos.

Les paso un script que utilizo para detectar si se tienen permisos directos a los usuarios de una base de datos, en caso de ser así, se listan los objetos y los permisos, yo lo utiliza dentro de un script de PowerShell que me indica en caso de obtener algun registro que se asignaron mal los permisos.

El script recorre todas las bases de datos y revisa si asignaron permisos directos.

Espero les sirva:

SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
CREATE PROCEDURE [dbo].[BPSQL_Revisa_Permisos_Users]
AS

DECLARE @dbname2 varchar(40);
declare @id varchar(30);

DECLARE dbname CURSOR FOR select name,database_id from master.sys.databases;

CREATE TABLE #Permisos_Users(
[base_de_datos] [varchar](128) NULL,
[usuario] [varchar](128) NULL,
[tipo_permiso] [varchar](128) NULL,
[objeto] [varchar](128) NULL
)

OPEN dbname
FETCH NEXT FROM dbname
INTO @dbname2,@id

WHILE @@FETCH_STATUS = 0
BEGIN
exec('SET NOCOUNT ON;
use [' + @dbname2 + ']
INSERT #Permisos_Users
select d.name,b.name,a.permission_name,c.name from sys.database_permissions a inner join sys.database_principals b on a.grantee_principal_id=b.principal_id
inner join sys.objects c on a.major_id=c.object_id,sys.databases d where b.type_desc in (''SQL_USER'',''WINDOWS_USER'',''WINDOWS_GROUP'') and b.default_schema_name is not null
and b.name <> ''dbo'' and b.name <> ''guest'' and a.permission_name <> ''CONNECT'' and convert(varchar,d.database_id)='+@id+'')

FETCH NEXT FROM dbname INTO @dbname2,@id
END

CLOSE dbname
DEALLOCATE dbname

select * from #Permisos_Users

drop table #Permisos_Users

Verificando Integridad de Backup Devices.

2009-05-27T15:04:00.004-05:00

Recientemente modifique el script que había publicado anteriormente para detectar si en el servidor de respaldo existen todos los backup devices del servidor operativo, usando PowerShell.

El script es muy simple, solamente basta conectarnos a cada servidor SQL usando SMO y guardar en un arreglo la lista de backup devices, despues recorrer los arreglos del servidor operativo y verificar si están en el de respaldo.

Aqui va el script:

[void][reflection.assembly]::LoadWithPartialName("Microsoft.SqlServer.Smo")
$srv=New-Object "Microsoft.SqlServer.Management.Smo.Server" SERVIDOROPERATIVO

$disp=@()
foreach($backup in $srv.backupdevices) {
$disp = $disp + $backup.Name
}

$srv2=New-Object "Microsoft.SqlServer.Management.Smo.Server" SERVIDORBACKUP
$disp2=@()
foreach($backup2 in $srv2.backupdevices) {
$disp2 = $disp2 + $backup2.Name
}

foreach ($dev in $disp) {
if ($disp2 -notcontains $dev){
Write-Host "No existe el backup " $dev "en el servidor de respaldo"
}
}

Solamente imprimirá si faltan backup devices en el servidor backup, pero se le puede agregar que lo escriba en un log, que mande un mail, etc.

Este script es parte de un plan de recuperacion de desastres, puesto que el servidor backup tiene que tener siempre los mismos backup devices del servidor operativo.

Espero les sirve.

Restaurando la BD model en SQL.

2009-04-09T15:19:00.003-05:00

Hace unos días, se hizo un restore de la base de datos model en el servidor backup por error, el problema fue que se hizo con la opción "With norecovery", esto ocasionó que se detuviera el servicio de SQL y ya no se pudiera levantar.

Buscando en internet, solamente encontré un artículo de Microsoft, explicando el problema y como solucionarlo el problema es que ese artículo no aplica para SQL 2005. Tambien encontré en un newsgroup de Microsoft una persona que le sucedió lo mismo y le explicaron un procedimiento y si no funcionaba se tenia que hacer un rebuild de la instalación.

Despues de estar intentando de diferentes maneras hacer levantar el servicio, al final pude hacerlo siguiente este procedimiento:

1. Levantar el servicio en single-user, con las opciones -c -m -T3608
2. Conectarse al servidor usando el comando osql
3. Hacer un detach de la base de datos:
use master
go
sp_detach_db 'model'
go
4. Copiar los archivos model.mdf y modellog.ldf a las mismas rutas del servidor (tienen que ser de otro servidor que tenga el mismo Service Pack de SQL)
5. Hacer el attach:
use master
go
sp_attach_db 'model','c:\Ruta\del\archivo_mdf','c:\ruta\del\archivo_ldf'
6. Detener el servicio de SQL y levantarlo normalmente.

Espero les sirva.

Monitoreo de Event Viewers de servidores remotos en Windows 2003.

2009-03-31T15:09:00.003-06:00

Que tal,

Les comparto como poder monitorear event viewers de servidores Windows 2003 sin necesidad de permisos administrativos.

1. Obtener el SID del grupo o usuario al que se le quieren asignar los permisos, para esto correr el comando wbinfo -n "dominio\cuenta" en un servidor linux que tenga samba y que esté integrado al dominio, se puede obtener tambien desde Windows, registrando el archivo acctinfo.dll (regsvr32 acctinfo.dll) que viene incluido en el Resource Kit de Windows 2003, abriendo la consola de Active Directory Users and Computers y entrando a las propiedades de la cuenta o grupo.

2. Formar la cadena de permisos de la siguiente manera:

(;;;;;)

Por ejemplo:

(A;;0x1;;;S-1-2-21-1283441307-3045887142-1639236238-20210)

Con esta cadena se asignan permisos (A) de lectura (0x1) al grupo: midominio\grupo (1283441307-3045887142-1639236238-20210).

3. Asignar los permisos en los event viewers correspondientes, para esto hay que agregar la cadena obtenida en el paso anterior en la llave CustomSD que correspondan a los event viewers, la ruta en donde se encuentra este parámetro (en el registry) es:

HKEY_LOCAL_MACHINE\System\CurrentControlSet\Services\Eventlog\\CustomSD

Es importante que se agreguen los permisos, no se sustituya la llave existente, porque ocasionaría serios problemas.
Espero que les sirva.

Finding folders with specific dates old using the name.

2009-03-12T15:21:00.006-06:00

Hi,
Recently, I had to do a script that finds all folders in a directory who have a certain number of days, each folder has a date, with format YYYYMMDD, and I had to find all folders that were X numbers of days old to move it to another folder.

After spending some time figuring out how can I could that, I will share with you the main function that I used and that is working right now.

The most tricky part was to validate that the folder was a valid date.
Well this is how I did it:

$dtout=New-Object datetime
$GciFiles = get-childitem $Path | where-object { $_.PsIsContainer -and $_.Name -match '^20[0-9][0-9][0-1][0-9][0-3][0-9]$' -and ([datetime]::tryParseExact($_.Name,"yyyyMMdd",[System.Globalization.CultureInfo]::EnglishName,[System.Globalization.DateTimeStyles]::None,[ref]$dtOut)) } | Where-Object { ((get-date) - [datetime]::parseexact($_.Name,"yyyyMMdd",$null)).days -ge $days } | Select-Object name

First, I declared a variable named dtout, so I could use it later, then I use the variable GciFiles to store the return of the gci(I know I could do that in a single line, but I wanted that way):

$GciFiles = get-childitem $Path

Then, the result of the gci, I filter only the folders and the folders whose name had the correct format, and using the function tryParseExact, I can validate that the date.

$GciFiles = get-childitem $Path | where-object { $_.PsIsContainer -and $_.Name -match '^20[0-9][0-9][0-1][0-9][0-3][0-9]$' -and ([datetime]::tryParseExact($_.Name,"yyyyMMdd",[System.Globalization.CultureInfo]::EnglishName,[System.Globalization.DateTimeStyles]::None,[ref]$dtOut)) }

Then, after I validated the date and the date was valid, I obtain the number of days from the folder's day to today and if that number is greater or equal the $days parameter the name is selected:

$GciFiles = get-childitem $Path | where-object { $_.PsIsContainer -and $_.Name -match '^20[0-9][0-9][0-1][0-9][0-3][0-9]$' -and ([datetime]::tryParseExact($_.Name,"yyyyMMdd",[System.Globalization.CultureInfo]::EnglishName,[System.Globalization.DateTimeStyles]::None,[ref]$dtOut)) } | Where-Object { ((get-date) - [datetime]::parseexact($_.Name,"yyyyMMdd",$null)).days -ge $days } | Select-Object name

Tips para actualizar el SP3 de SQL 2005.

2009-02-04T14:48:00.004-06:00

Que tal,
Hace poco terminé de actualizar mi servidores SQL 2005 al SP3 CU1, así que les compartiré algunos tips, para aquellos que aún no lo han hecho.

En general, este Service Pack no da problemas, bueno eso, si el folder C:\windows\installer se mantiene intacto, de lo contrario puede dar algunos problemas y ser mas problematico. Los errores que me han tocado y que he visto son de que al momento de la instalación falle en la instalación del SP en algun componente, pero nunca he visto, que deje el servidor "tocado", o que ya nunca levante. En posts anteriores en este blog hablo de algunos de ellos.

Yo recomendaría que actualizaran al SP3 y de una vez al Cumulative Update 1, ya que los fixes que tiene, valen la pena, son solo 15 minutos mas en el procedimiento.

Aqui comparto algunos tips:
1. Si ya tienes instalado el SP2 en el servidor, descomprime el ejecutable del SP2 (con el 7-zip) y verifica el tamaño que tiene el archivo que viene en el folder hotfixtools, despues verifica que exista un archivo con el mismo tamaño en el folder C:\windows\installer, si existe es que no habrá problema, si no, ya sabes que en ese punto te puede fallar, si tienes un cluster, el archivo solamente estará en el servidor en donde se realizó la instalación.
2. Existe un bug en el cual, la cuenta con la que corre el servicio de SQL no debe ser domain admin, así que ya sabes, si así es, primero sacala del grupo domain admins.
3. Al momento de la instalación, si es un cluster, verifica que no haya alguien logueado por Remote Desktop en el otro nodo.
4. La instalación del SP en un cluster, es un poco tardada, dependiendo del número de nodos y de otras cosas, pero en mi caso, en servidores de 2 nodos, se tarda en total aprox. 40 minutos, así que hay que abrir una ventana de mantenimiento lo suficientemente holgada, a esto hay que añadir lo que se tardan los restarts de los nodos y los failovers. El CU1 se tarda aprox. entre 15 y 20 minutos.
5. Haz un backup completo de todas las bases de datos, nunca sabes que puede pasar y es mejor estar preparado, esto le aumenta tiempo en la instalación, pero es mejor prevenir, que lamentar.
6. De preferencia, antes de que lo vayas a instalar, instala el Windows Installer 4.5.
7. Se tiene que correr el instalador en el nodo en donde está el servicio de SQL funcionando.
8. Al momento de la instalación en cluster, de repente se queda en el mensaje: "Awaiting first complete passive cluster node SQLSERVER", a mi se me tardó en este punto, aprox. 10 minutos, pero despues avanzó, para que no se preocupen y no cancelen la instalación.
9. Revisa bien la estrategia de Disaster Recovery de tus servidores y preparate para el peor escenario, es mejor, estar siempre bien preparados y contar una buena estrategia de recuperacion de datos, si no existe, este es el momento de empezar.

Estos son los pasos que yo realize en cluster active-passive de 2 nodos:
1. Hacer failover de SQL hacia la instancia en donde hize la instalacion.
2. Correr script para deshabilitar jobs. Este script se puede generar utilizando mi script que tengo en otro de mis posts.
3. Correr script para matar conexiones y poner bds en read-only.
4. Correr script para backup de bases de datos.
5. Correr instalador del SP3.
6. Reiniciar el segundo nodo.
7. Hacer failover de SQL al segundo nodo.
8. Reinciar el primer nodo.
9. Instalar el CU1.
10. Reiniciar el segundo nodo.
11. Hacer failover de SQL hacia el segundo nodo.
12. Reiniciar el primer nodo.
13. Correr script para poner bases de datos en read-write.
14. Correr script para habilitar jobs.
15. Verificar aplicaciones que se conectan al servidor, conectividad, delegación, etc.

En teoría no es necesario reiniciar los nodos y hacer failovers despues de aplicar el CU1, pero yo lo hize para estar bien seguro de que no habrá problemas.

Si alguien quiere hacer algun comentario o hacerme preguntas acerca de algo, con todo gusto le ayudaré.

Verifying logins integrity between SQL 2005 servers with PowerShell.

2009-02-04T14:33:00.003-06:00

Hi,
Recently I had to verify that every login in my production servers were in my backup servers, so I did a script using PowerShell to do that. This script is useful if you want to make sure that all your backup servers have the production logins.

The script takes 2 parameters, the production server and the backup server, all the logins in the production server must be in the backup server, in case it finds someone is missing, it writes it in a log and displays the login in the console.

This is the script:
param (
[string]$ServerOp ,
[string]$ServerBackup)

$LogFile = "C:\Intlogins\logs\Int_LOGINS_$nombre.log"

out-file -filepath $LogFile -inputobject ("#############################################################################################################################################")
out-file -filepath $LogFile -inputobject (" ") -append
out-file -filepath $LogFile -inputobject " START PROCESS TO VERIFY LOGINS INTEGRITY " -append
out-file -filepath $LogFile -inputobject (" ") -append
out-file -filepath $LogFile -inputobject ("#############################################################################################################################################") -append
out-file -filepath $LogFile -inputobject (" ") -append

$SqlConnection = New-Object System.Data.SqlClient.SqlConnection
$SqlConnection.ConnectionString = "Server=$serverOp;Database=master;Integrated Security=True"
$SqlCmd = New-Object System.Data.SqlClient.SqlCommand
$SqlCmd.CommandText = "select name from master.sys.server_principals where is_disabled=0 and principal_id>258 and name <>'##MS_AgentSigningCertificate##'"
$SqlCmd.Connection = $SqlConnection
$SqlAdapter = New-Object System.Data.SqlClient.SqlDataAdapter
$SqlAdapter.SelectCommand = $SqlCmd
$DataSet = New-Object "System.Data.DataSet" "Table1"
$result = $SqlAdapter.fill($DataSet)

$SqlConnection2 = New-Object System.Data.SqlClient.SqlConnection
$SqlConnection2.ConnectionString = "Server=$serverBackup;Database=master;Integrated Security=True"
$SqlCmd2 = New-Object System.Data.SqlClient.SqlCommand
$SqlCmd2.CommandText = "select name from master.sys.server_principals where is_disabled=0 and principal_id>258 and name <>'##MS_AgentSigningCertificate##'"
$SqlCmd2.Connection = $SqlConnection2
$SqlAdapter2 = New-Object System.Data.SqlClient.SqlDataAdapter
$SqlAdapter2.SelectCommand = $SqlCmd2
$DataSet2 = New-Object "System.Data.DataSet" "Table1"
$result2 = $SqlAdapter2.fill($DataSet2)

foreach ($row in $dataset.Tables[0].rows){
$exist=0
foreach ($row2 in $Dataset2.Tables[0].rows){
if([string]::Compare($row2.name,$row.name,$True) -eq 0){
# Write-Host "The login" $row.name "exists in backup server"
$exist=1
break
}
}
if ($exist -eq 0){
Write-Host "The login" $row.name "does NOT exist in backup server"
$var = "$hora ERROR: The login ["+ $row.name+ "] does NOT exist in backup server: $ServerBackup"
out-file -filepath $LogFile -inputobject $var -append

}
}

out-file -filepath $LogFile -inputobject (" ") -append
out-file -filepath $LogFile -inputobject (" ") -append
out-file -filepath $LogFile -inputobject ("#############################################################################################################################################") -append
out-file -filepath $LogFile -inputobject (" ") -append
out-file -filepath $LogFile -inputobject (" END PROCESS TO VERIFY LOGINS INTEGRITY") -append
out-file -filepath $LogFile -inputobject (" ") -append
out-file -filepath $LogFile -inputobject ("#############################################################################################################################################") -append

Mas del SP3 de SQL 2005.

2009-01-21T15:31:00.001-06:00

Había comentado en el blog anterior que uno de mis servidores nunca pude actualizar el Client Components, pues bien, en uno de los foros de Microsoft, encontré que la solución estaba en tomar el archivo faltante del SP2, no del SP3, como le había hecho antes.

Pues bien, despues de sustituir el archivo faltante del folder Windows Installer, pude terminar la instalación del SP3 y del CU1.

Instalando el SP3 de SQL 2005.

2009-01-16T13:01:00.004-06:00

Que tal,
Desde hace unos días empezé a instalar el SP3 de SQL 2005 en los servidores, hasta el momento llevo 2/3 que funcionan a la primera.

El día de ayer intente instalarlo en un servidor que es backup de los operativos, tiene 2 instancias de SQL 2005, la primera vez que corrí el instalador no se instaló en el database engine default y de la instancia y el client components, todo lo demás si se actualizó.

Hice varias pruebas, pero el resultado fue igual, revisando el log de instalación, encontré unas líneas con el error, indicando que faltaba un archivo: " Couldn't find local patch 'C:\WINDOWS\Installer\ce61b.msp'. Looking for it at its source.", en un blog de msdn encontré como corregir el problema, basicamente lo que hay que hacer es descomprimir el archivo de instalación, (con el 7-zip, por ejemplo) buscar el archivo que hace referencia un poco mas adelante en el log (en este caso era: sqlrun_tools.msp) y copiarlo en el folder C:\windows\installer, renombrado con el nombre que dice ahí ce62b.msp, después de hacer eso volví a correr el instalar y ahora me falló pero con el archivo C:\WINDOWS\Installer\ce62b.msp y volví a copiar el archivo.

Después de hacer eso, volvió a fallar, pero ahora avanzaba un poco más y ya no marcaba ese error, ahora el error en los logs era : "Error 2902. The installer has encountered an unexpected error. The error code is 2902. Operation ixfAssemblyCopy called out of sequence.", para este error encontré un artículo indicando que era un bug en el Windows Installer 3.1 y que ya había sido corregido en el Windows Installer 4.5, así que instalé el Windows Installer 4.5 en el servidor y ya pudo terminar la instalación en las instancias, en los Client Components nunca pudo terminar, siempre estuvo marcando error.

Despues de eso, instalé el Acumulativo 1 en el servidor y se instaló sin problemas.

Así que lo haré a partir de ahora será actualizar primero el Windows Installer a la 4.5 antes de instalar el SP3.

Esta es la liga del blog que les decía:
http://blogs.msdn.com/heaths/archive/2006/11/30/rebuilding-the-installer-cache.aspx

Espero que esto les sirva.

Esta es la liga del blog que les decía:
http://blogs.msdn.com/heaths/archive/2006/11/30/rebuilding-the-installer-cache.aspx

Script to migrate databases with PowerShell.

2008-12-31T09:39:00.002-06:00

Hi,
In the last months, I've been writing some scripts in PowerShell to administer SQL Servers, this time, I will share my personal script to migrate database from one server to another.

You can test this script in your environment and see if it works, this is the scripts that I have used to migrate databases easily and quickly.

First, you have to kill all the processes in the databases and change them to read only, in order to guarantee that the data will not change during the migration.

The script read a txt file with the list of all databases to migrate, then it connects to source server, then, for every database it checks whether if it should migrate them, and takes a full backup, also it generates the scripts to re-create the database users, the script to add every user to its respective role and checks if there is any schema that its owner is different than dbo.

Then, it copies the backups to the backup server, restore it, change it to read_write, run the scripts to recreate users and add them to the roles.

One important thing is that it considers that if the data and log files are going to be different between the servers, it lets you specfy a new route, with some parameters.

The scripts take these parameters:
1. A txt file with the databases name to migrate. (for example: d:\databases.txt)
2. Path in the soruce server where the source server will write the backup (for example: d:\backups)
3. Path in the backup server where the backup server will take the backup (for example: d:\backups)
4. Path where will be written the scripts.
5. Source database server name.
6. Backup database server name.

For example:
# ./migradbs.ps1 d:\databases.txt d:\backups\ h:\backups\ d:\scripts "MYCURRENTSERVER" "MYNEWSERVER"

param (
[string]$filename=$(throw 'The parameter: $filename is required.'),
[string]$BackupPath=$(throw 'The parameter: $BackupPath is required.'),
[string]$RestorePath=$(throw 'The parameter: $RestorePath is required.'),
[string]$ScriptsPath=$(throw 'The parameter: $ScriptsPath is required.'),
[string]$OriginServer=$(throw 'The parameter: $OriginServer is required.'),
[string]$DestinyServer=$(throw 'The parameter: $DestinyServer is required.')
)
# MODIFY THIS PARAMETERS TO CHANGE THE PATHS FROM THE DATA AND LOGS.
# IF YOU LET IT WRONG, THE RESTORE WILL FAIL Y THE SCRIPT WILL EXIT WITH SOMETHING LIKE:
# Exception calling "SqlRestore" with "1" argument(s): "Restore failed for Server ?????'. "
# At :line:197 char:22 $restore.SqlRestore( <<<< $srv2)
[string]$path_data_source="d:\sql\"
[string]$path_log_source="d:\sql\"
[string]$path_data_backup="d:\sql\"
[string]$path_log_backup="d:\sql\"

if (! (test-path $filename)) {
throw "$($filename) is not a valid file!"
}

if (! (test-path $ScriptsPath)) {
throw "$($ScriptsPath) is not a valid path!"
}

$bds=Get-Content $filename | where {$_ -ne ""}
function okMigrate([string]$a) {
foreach ($bd in $bds){
if ([string]::Compare($a, $bd, $True) -eq 0){
return $true
break
}
}
return $false
}
[System.Reflection.Assembly]::LoadWithPartialName("Microsoft.SqlServer.Smo") | out-null
$MyScripter=new-object ("Microsoft.SqlServer.Management.Smo.Scripter")
$srv=New-Object "Microsoft.SqlServer.Management.Smo.Server" $OriginServer
$MyScripter.Server=$srv

if (!$BackupPath.EndsWith("\")){ $BackupPath += "\" }
if (!$RestorePath.EndsWith("\")){ $RestorePath += "\" }
if (!$ScriptsPath.EndsWith("\")){ $ScriptsPath += "\" }
Write-Host "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
Write-Host " START SCRIPT TO MIGRATE DATABASES "
Write-Host "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
Write-Host "Backup path:" $BackupPath
Write-Host "Restore path:" $RestorePath
Write-Host "Scripts path:" $ScriptsPath
Write-Host "Source server:" $OriginServer
Write-Host "backup server:" $DestinyServer
Write-Host "DBS to migrate:" $bds
$mytime=get-date -uformat "%Y/%m/%d %H:%M:%S"
Write-Host "Current date and time:" $mytime
Write-Host "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"

foreach($database in $srv.databases) {
if (okMigrate($database.Name) -and $database.Name -ne "master" -and $database.Name -ne "model" -and $database.Name -ne "msdb" -and $database.Name -ne "tempdb"){
$backup=new-object "Microsoft.SqlServer.Management.Smo.Backup"
$backup.Action='Database'
$backup.Initialize='true'
$backup.Checksum='true'
$fil=new-object "Microsoft.SqlServer.Management.Smo.BackupDeviceItem"
$fil.DeviceType='File'
$fil.Name=[System.IO.Path]::Combine($BackupPath, $database.Name + ".bak")
$backup.Devices.Add($fil)
$backup.Database=$database.Name
write-host "Start backup of"$database.Name
$backup.SqlBackup($srv)
write-host "Finished backup of"$database.Name
#write-host "Getting the script to recreate the users of" $database.Name
$f = [System.IO.Path]::Combine($ScriptsPath, "Users_" + $database.Name + ".sql")
$MyScripter.options.IncludeDatabaseContext = $false
$e = "USE " + $database.Name
out-file -filePath $f -inputobject $e
out-file -filePath $f -inputobject "GO" -Append
foreach ($User in $database.Users) {
if ($User.Name -ne "sys" -and $User.Name -ne "dbo" -and $User.Name -ne "INFORMATION_SCHEMA" -and $User.Name -ne "guest") {
$MyScripter.Options.IncludeIfNotExists = $true
$MyScripter.Options.ScriptDrops = $true
$MyScripter.Script($User) | Out-file $f -append
}
if ($User.Name -ne "sys" -and $User.Name -ne "dbo" -and $User.Name -ne "INFORMATION_SCHEMA" -and $User.Name -ne "guest") {
$MyScripter.options.IncludeDatabaseContext = $false
$MyScripter.Options.ScriptDrops = $false
$MyScripter.Script($User) | Out-file $f -append
out-file -filePath $f -inputobject "`n" -append
}
}
#write-host "Getting the script to add every user to its roles..."
$f = [System.IO.Path]::Combine($ScriptsPath, "roles_" + $database.Name + ".sql")
$e = "USE " + $database.Name
out-file -filePath $f -inputobject $e
out-file -filePath $f -inputobject "GO" -Append
foreach ($role in $database.Roles) {
if ($role.Name -ne "public") {
foreach ($member in $role.EnumMembers()) {
if ($member -ne "dbo") {
$var = "sys.sp_addrolemember @rolename = N'" + $role.Name+"', @membername = N'"+$member+"'"
out-file -filePath $f -inputobject $var -append
out-file -filePath $f -inputobject "GO" -append
}
}
}
}

#Write-Host "Getting the scripts to change the paths during restore"
ForEach ($fg in $database.FileGroups){
foreach ($var1 in $fg.Files){
$movedata = $var1.Name + "," + ($var1.FileName.ToLower()).Replace($path_data_source,$path_data_backup)
}
}
ForEach ($lf in $database.LogFiles){
$movedata_log = $lf.Name + "," + ($lf.FileName.ToLower()).Replace($path_log_source,$path_log_backup)
}
$f = [System.IO.Path]::Combine($ScriptsPath, "Relocate_" + $database.Name + ".relocate")
out-file -filePath $f -inputobject $movedata
$f = [System.IO.Path]::Combine($ScriptsPath, "Relocate_" + $database.Name + "_log.relocate")
out-file -filePath $f -inputobject $movedata_log

$SqlConnection1 = New-Object System.Data.SqlClient.SqlConnection
$SqlConnection1.ConnectionString = "Server=$OriginServer;Database=master;Integrated Security=True"
$SqlConnection1.open()
$SqlCmd = New-Object System.Data.SqlClient.SqlCommand
$SqlCmd.CommandText = "select * from $database.sys.schemas where name not in ('dbo','sys','guest','INFORMATION_SCHEMA','db_accessadmin','db_backupoperator','db_datareader','db_datawriter','db_ddladmin','db_denydatareader','db_denydatawriter','db_owner','db_securityadmin') and principal_id<>1"
$SqlCmd.Connection = $SqlConnection1
$SqlAdapter = New-Object System.Data.SqlClient.SqlDataAdapter
$SqlAdapter.SelectCommand = $SqlCmd
$DataSet = New-Object "System.Data.DataSet" "Table2"
$resultado = $SqlAdapter.fill($DataSet)
if ($resultado -gt 0) {
write-host "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
write-host "WARNING: There are schemas which its owner its not dbo!"
write-host "To fix the problem: Change the schema owner, BEFORE migrate"
write-host "To change the owner run: ALTER AUTHORIZATION ON SCHEMA:: TO dbo"
write-host "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
}
$DataSet.clear()
$SqlConnection1.close()
}
}
Write-Host "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
write-host " DATABASE BACKUP FINISHED "
Write-Host "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"

if ($OriginServer.Contains("\")){
$mypath1 = $OriginServer.Substring(0,$OriginServer.IndexOf("\"))
} elseif ($OriginServer.Contains(",")){
$mypath1 = $OriginServer.Substring(0,$OriginServer.IndexOf(","))
} else {
$mypath1 =$OriginServer
}
$tempSourceDir = "\\" + $mypath1+ "\" + ($BackupPath -replace(":","$"))

if ($DestinyServer.Contains("\")){
$mypath2 = $DestinyServer.Substring(0,$DestinyServer.IndexOf("\"))
} elseif ($DestinyServer.Contains(",")){
$mypath2 = $DestinyServer.Substring(0,$DestinyServer.IndexOf(","))
} else {
$mypath2 =$DestinyServer
}
$tempTargetDir = "\\" + $mypath2 + "\" + ($RestorePath -replace (":","$"))

$srv2=New-Object "Microsoft.SqlServer.Management.Smo.Server" $DestinyServer
$SqlConnection = New-Object System.Data.SqlClient.SqlConnection
$SqlConnection.ConnectionString = "Server=$DestinyServer;Database=master;Integrated Security=True"
$SqlConnection.Open()

foreach ($myfile in [System.IO.Directory]::GetFiles($tempSourceDir,"*.bak")) {
$mydbname = ($myfile.Remove(0,$tempSourceDir.Length)) -replace (".bak","")
if (okMigrate($mydbname) -and $database.Name -ne "master" -and $database.Name -ne "model" -and $database.Name -ne "msdb" -and $database.Name -ne "tempdb"){
Write-Host "Start copying of" $myfile "to" $tempTargetDir
Copy-Item $myfile -Destination $tempTargetDir
Write-Host "Finished copying"
$restore=new-object "Microsoft.SqlServer.Management.Smo.Restore"
$restore.Action='Database'
$fil2=new-object "Microsoft.SqlServer.Management.Smo.BackupDeviceItem"
$fil2.DeviceType='File'
$fil2.Name=[System.IO.Path]::Combine($RestorePath,$mydbname+".bak")
$restore.Database=$mydbname
$restore.ReplaceDatabase='True'
$restore.Checksum='True'
$restore.Devices.Add($fil2)
#$restore.RelocateFiles.Clear()
$relocate_data=Get-Content ($ScriptsPath + "Relocate_" + $mydbname + ".relocate")
$DataFile=$relocate_data.Split(",")
$relocateDataFile=new-object("Microsoft.SqlServer.Management.Smo.RelocateFile")($DataFile[0],$DataFile[1])
$restore.RelocateFiles.Add($relocateDataFile) | Out-Null
$relocate_log=Get-Content ($ScriptsPath + "Relocate_" + $mydbname + "_log.relocate")
$LogFile=$relocate_log.Split(",")
$relocateLogFile=new-object("Microsoft.SqlServer.Management.Smo.RelocateFile")($LogFile[0],$LogFile[1])
$restore.RelocateFiles.Add($relocateLogFile) | Out-Null
Write-Host "Empieza el restore de"$mydbname
$restore.SqlRestore($srv2)
Write-Host "Termina el restore de"$mydbname
$SqlCmd = New-Object System.Data.SqlClient.SqlCommand
$SqlCmd.Connection = $SqlConnection
Write-Host "Changing" $mydbname "to Read_Write"
$SqlCmd.CommandText ="ALTER DATABASE $mydbname SET READ_WRITE"
$SqlCmd.ExecuteNonQuery() | Out-Null
Write-Host "Recreating users of"$mydbname
[diagnostics.process]::start("sqlcmd.exe","-S$DestinyServer -E -i`"" + $ScriptsPath + "Users_" + $mydbname + ".sql`"").WaitForExit()
Write-Host "Adding users of"$mydbname "to its roles"
[diagnostics.process]::start("sqlcmd.exe","-S$DestinyServer -E -i`"" + $ScriptsPath + "roles_" + $mydbname + ".sql`"").WaitForExit()
$srv2.Refresh()
}
Write-Host "Finished restore of"$mydbname
}
$SqlConnection.Close()
Write-Host "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
Write-host " END OF SCRIPT "
Write-Host "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
$mytime=get-date -uformat "%Y/%m/%d %H:%M:%S"
Write-Host "Current date and time:" $mytime

Error al levantar servicio de cluster de sql.

2008-12-15T15:06:00.003-06:00

Que tal,
Esta semana con los parches de Microsoft, tuve un incidente un poco raro. Al instalar los parches en uno de los nodos, el servicio de cluster nunca levantó.

En el event viewer se registraba lo siguiente:

Cluster node MYCLUSTER failed to make a connection to the node over network 'Hearbeat'. The error code was 5.

The node cannot join the server cluster because it cannot communicate with node MYOTHERNODE over any network configured for internal server cluster communication. Check the network configuration of the node and the server cluster.

Después de estar por unos minutos reintando que levantara el servicio y justo cuando estabamos pensando en restaurar el system state del servidor, dimos con este artículo de la KB de microsoft: http://support.microsoft.com/kb/317232

El artículo aplica solo para servidores Windows NT y 2000 y mis servidores son Windows 2003, de igual manera seguimos la recomendación, que simplemente era reiniciar el servicio de cluster en el nodo que estaba funcionando, despues de hacer esto, el servidor pudo arrancar el servicio de cluster.

Cabe mencionar que hace un par de semanas, la cuenta con la que corre el servicio de cluster se le cambió su password, que fue cambiado, por cierto, usando el comando cluster, aquella vez no hubo problemas, estas son algunas de las cosas raras que pasan.

Configuracion de memoria en instancias de SQL.

2008-11-24T15:22:00.002-06:00

Hace poco leí un artículo muy interesante en el blog Paul Randal acerca de configurar la memoria de varias instancias en servidores SQL 2005.

Basicamente lo que hay que hacer si se tiene un servidor SQL 2005-2008 con varias instancias de SQL que corren en diferentes máquinas, es asignar como memoria mínima el 40% del total de la memoria, este tip, me pareció muy interesante, porque hasta ahora todos los artículos que había visto en internet, decían que habia que poner como máximo el 40% de la memoria, para que en caso de estar las 2 instancias en el mismo nodo, no hubiera problemas.

Hay que recordar que esta memoria solo es la del buffer pool memory, no es la memoria que está consumiendo la instancia de SQL.

Para más información se puede ver este link

Viendo los permisos de los roles.

2008-11-10T15:28:00.003-06:00

Muchas veces, nos topamos con que necesitamos obtener los permisos que tiene una base de datos en partícular, pero no podemos obtener todos los permisos rápidamente o los necesitamos exportar a excel, o queremos hacer una auditoría de permisos...

Para estas ocasiones aquí está un script que obtiene los permisos de una base de datos a todos los roles...

SELECT a.name as OBJETO,c.name as Rol, 'INSERT' as Permiso
FROM SYS.SYSOBJECTS A INNER JOIN sys.database_permissions B ON A.ID=B.MAJOR_ID INNER JOIN sys.database_principals c on b.grantee_principal_id=c.principal_id
where b.permission_name='INSERT' and a.name<>'dtproperties'
union
SELECT a.name as OBJETO,c.name as Rol, 'UPDATE' as Permiso
FROM SYS.SYSOBJECTS A INNER JOIN sys.database_permissions B ON A.ID=B.MAJOR_ID INNER JOIN sys.database_principals c on b.grantee_principal_id=c.principal_id
where b.permission_name='UPDATE' and a.name<>'dtproperties'
union
SELECT a.name as OBJETO,c.name as Rol, 'DELETE' as Permiso
FROM SYS.SYSOBJECTS A INNER JOIN sys.database_permissions B ON A.ID=B.MAJOR_ID INNER JOIN sys.database_principals c on b.grantee_principal_id=c.principal_id
where b.permission_name='DELETE' and a.name<>'dtproperties'
union
SELECT a.name as OBJETO,c.name as Rol, 'EXECUTE' as Permiso
FROM SYS.SYSOBJECTS A INNER JOIN sys.database_permissions B ON A.ID=B.MAJOR_ID INNER JOIN sys.database_principals c on b.grantee_principal_id=c.principal_id
where b.permission_name='EXECUTE' and a.name<>'dtproperties'
union
SELECT a.name as OBJETO,c.name as Rol, 'SELECT' as Permiso
FROM SYS.SYSOBJECTS A INNER JOIN sys.database_permissions B ON A.ID=B.MAJOR_ID INNER JOIN sys.database_principals c on b.grantee_principal_id=c.principal_id
where b.permission_name='SELECT' and a.name<>'dtproperties'
union
SELECT a.name as OBJETO,c.name as Rol, 'VIEW DEFINITION' as Permiso
FROM SYS.SYSOBJECTS A INNER JOIN sys.database_permissions B ON A.ID=B.MAJOR_ID INNER JOIN sys.database_principals c on b.grantee_principal_id=c.principal_id
where b.permission_name='VIEW DEFINITION' and a.name<>'dtproperties'

Lo pueden correr tranquilamente en sus servidores sin problemas de performance, este script lo utilizo regularmente para hacer auditorías de los permisos...

Obtiene un resultado parecido a este:
Objeto Rol Permiso
Tabla1 rol_users_rh select

Solamente se incluyen los permisos de select, insert, update, delete, execute y view definition, pero se le pueden agregar todos los permisos....

Espero les sirva.

Grupos anidados en SQL 2005

2008-10-28T15:38:00.002-06:00

Recientemente, necesitaba agregar un grupo local en mi servidor SQL, para esto tenía un grupo local en mi dominio y en ese grupo local, existia otro grupo global de otro dominio, esto que pretendía hacer, era para facilitar la administración, ya que si en el grupo del otro dominio agregaban o quitaban personas, yo no tenía que hacer ningun cambio.

Bueno, despues de las pruebas que estuve haciendo, llegué a la conclusión que no se pueden tener grupos anidados en SQL 2005, si se necesita agregar un grupo en el servidor, es necesario que en ese grupo estén los miembros, no se pueden estar anidadando grupos, porque simplemente no funciona y la verdad, no creo que en el futuro, vaya a funcionar.

En fin, al final de cuentas, tuve que agregar a los usuarios al grupo de mi dominio.

Instalando instancias de SQL 2005 en diferentes ips.

2008-10-08T17:43:00.003-05:00

Hace unos días, tenía que instalar una segunda instancia de SQL 2005 en un servidor backup, lo interesante era, que esta instancia tenía que tener otra ip diferente, debido a que este servidor backup era el respaldo de 2 servidores, uno con la instancia default y otro con instancia.

Esto con SQL 2000 no fuera posible, pero ya en SQL 2005 es posible, quedando la instancia default con una ip y la otra instancia con otra ip, estos son los pasos que realizé:

1. Instalar la instancia usando el setup de SQL 2005.
2. Agregar la segunda ip del servidor.
3. Abrir la consola del SQL Server Configuration Manager, en la sección SQL Server 2005 Network Configuration, abrir los protocols para la instancia default.

En el tab Protocol, la sección Listen All: No
En el tab IP Addresses, seleccionar la ip al que quedará bindeada la instancia default, y deberá quedar así:
Active: Yes
Enabled: Yes
IP Address: (la ip a bindear)
TCP Dynamic Ports (en blanco)
TCP Port: 1433

Al final en IPALL:
TCP Dynamic Ports (en blanco)
TCP Port: 1433

Ahora configurar la ip para la otra instancia:
En la sección TCP/IP de Protocols, configurar lo siguiente:
En el tab Protocol, la sección Listen All: No
En el tab IP Addresses, seleccionar la ip al que quedará bindeada la otra instancia y deberá quedar así:
Active: Yes
Enabled: Yes
IP Address: (la ip a bindear)
TCP Dynamic Ports (en blanco)
TCP Port: 1433

Al final en IPALL:
TCP Dynamic Ports (en blanco)
TCP Port: 1433

Después de hacer esto hay que reiniciar los servicios de SQL de la instancia default y de la otra instancia.

Como esta segunda ip no se está registrando en los DNS, puede ser necesario crear un registro host en los DNS asignandole un nombre y crear un c-name apuntando al host.

Es importante que el servicio SQL Server Browser esté encendido para que se pueda direccionar correctamente al usuario a la instancia que le corresponde.

Para saber que esto está configurado correctamente se puede correr el siguiente comando desde un Command Prompt:

netstat -an | find "LISTEN" | find "143"

Que deberá dar como resultado, algo parecido a esto:
TCP 192.168.0.1:1433 0.0.0.0:0 LISTENING
TCP 192.168.0.2:1433 0.0.0.0:0 LISTENING
TCP 127.0.0.1:1434 0.0.0.0:0 LISTENING

Lo cual indica que cada ip tiene asignada una instancia.

Scripting role members in every database using PowerShell.

2008-09-23T15:36:00.004-05:00

Hi,
Starting this post I will be writing in English, in order to reach the users from the PowerShell Community.

Previously, I shared some scripts written in PowerShell to generate automatically some configurations (like users, jobs, linked servers, etc) in SQL Server 2005 using SMO with PowerShell.

In this post, I wrote a script to generate the users in every database, that script had an error, the script generated needed a GO command before the instruction to add the user to their respective role.

So, I created this script to generate a script with the sys.sp_addrolemember instruction for every role,it is helpful if you want to restore any database in other server (you would need first to recreate the users with the other script) or in case a Disaster Recovery scenario.

So, this is the script:

param (
[string] $serverName
)
$Scripts = "c:\scripts\"

[reflection.assembly]::LoadWithPartialName("Microsoft.SqlServer.Smo") | out-null
$MyScripter=new-object ("Microsoft.SqlServer.Management.Smo.Scripter")
$srv=New-Object "Microsoft.SqlServer.Management.Smo.Server" $serverName

foreach($db in $srv.databases) {
if ($db.Name -ne "master" -and $db.Name -ne "model" -and $db.Name -ne "msdb" -and $db.Name -ne "tempdb") {
$f = [System.IO.Path]::Combine($Scripts, $srv.Name +"_roles_" + $db.Name + ".sql")
out-file -filePath $f -inputobject "USE $db"
out-file -filePath $f -inputobject "GO" -Append
foreach ($role in $db.Roles) {
if ($role.Name -ne "public") {
foreach ($member in $role.EnumMembers()) {
if ($member -ne "dbo") {
$var = "sys.sp_addrolemember @rolename = N'" + $role.Name+"', @membername = N'"+$member+"'"
out-file -filePath $f -inputobject $var -append
out-file -filePath $f -inputobject "GO" -append
}
}
}
}
}
}

To run this script, you just need to specify the sql server and it will generate in c:\scripts a file for every database containing the script to add the members for every user, just like this:

USE [MyDB]
GO
sys.sp_addrolemember @rolename = N'HR', @membername = N'user1'
GO
sys.sp_addrolemember @rolename = N'sales', @membername = N'user2'
GO

Mas de los esquemas en SQL 2005.

2008-09-10T18:43:00.003-05:00

En un post anterior comentaba acerca de lo recomendable que era que los owners de los esquemas no debían ser los mismo usuarios, para evitar problemas en futuras migraciones.

Pues bien, según una entrada del blog de Microsoft ISV Program Management Team, lo mejor que puedes hacer después de haber migrado a SQL 2005 es cambiar el default esquema de los usuarios a dbo, esto te dará un aumento de hasta un 15% en el throughput del servidor, esto, si en las llamadas que se hacen a los objetos no se incluye "dbo", que es un best practice, por cierto.

Se puede cambiar el default esquema de los usuarios fácilmente con el comando ALTER USER WITH DEFAULT_SCHEMA=dbo

Se puede utilizar este script para obtener como respuesta el script que se tiene que correr en cada base de datos:

select 'alter user '+ name + ' with DEFAULT_SCHEMA=dbo;'
from sys.database_principals
where default_schema_name is not null and name<>'dbo' and name <>'guest' and default_schema_name<>'dbo'

Esto se corre en cada base de datos, en la que se desea hacer y se obtiene de resultado el script con el que se cambian todos los usuarios rápidamente.

Una vez que se cambió el default esquema de los usuarios, lo recomendable es eliminar los esquemas de los usuarios, con este script se pueden obtener el script para eliminar los esquemas por cada base de datos:

select 'DROP SCHEMA '+ name + ';'
from sys.schemas
where schema_id between 5 and 16383

Detectando logins huérfanos.

2008-09-03T15:56:00.006-05:00

Un script que puede ser útil para quienes tienen servidores SQL 2005 y que necesitan saber rápidamente si tienen en sus servidores logins que ya nadie los ocupa, es decir, no están como usuarios en ninguna base de datos, no están como local user en ningún linked server, no pertenecen a ningún rol de servidor y están habilitados.

Aquí está el código:

DECLARE @dbname2 varchar(40);
DECLARE dbname CURSOR FOR select name from master.sys.databases';

OPEN dbname
FETCH NEXT FROM dbname
INTO @dbname2

create table #nombres(
nombre varchar (128))

WHILE @@FETCH_STATUS = 0
BEGIN
exec('SET NOCOUNT ON;
use [' + @dbname2 + ']
INSERT #nombres
select b.name
from sys.database_principals a inner join sys.server_principals b on a.sid=b.sid
where a.type_desc <> ''DATABASE_ROLE'' and a.name <> ''dbo''
and a.name <> ''guest'' and a.name <> ''INFORMATION_SCHEMA'' and a.name <> ''sys'' ')
FETCH NEXT FROM dbname INTO @dbname2
END

CLOSE dbname
DEALLOCATE dbname

DECLARE users CURSOR FOR select distinct(nombre) from #nombres order by nombre;
declare @usuario varchar(128);

OPEN users
FETCH NEXT FROM users
INTO @usuario

create table #sids(
sid varbinary(256),
nombre varchar(128) )

WHILE @@FETCH_STATUS = 0
BEGIN
exec('SET NOCOUNT ON;
INSERT #sids
select suser_sid('''+ @usuario +'''),'''+@usuario+'''')
FETCH NEXT FROM users INTO @usuario
END

CLOSE users
DEALLOCATE users

select a.name as login
from sys.server_principals a left join #sids b on a.sid=b.sid
where b.sid is null and a.type_desc <>'CERTIFICATE_MAPPED_LOGIN' and a.type_desc <>'SERVER_ROLE' and a.name <> 'sa'
and a.name <>'BUILTIN\Administrators' and a.name <>'NT AUTHORITY\SYSTEM' and a.principal_id<>259
and a.principal_id not in (select distinct(local_principal_id) from sys.linked_logins) and a.is_disabled=0
and a.principal_id not in (select member_principal_id from sys.server_role_members)
order by a.name

drop table #nombres
drop table #sids

SQL 2005 y los esquemas.

2008-08-22T15:56:00.004-05:00

Para los que hicieron su migración de bases de datos de SQL 2000 a SQL 2005, usando el tradicional método de backup/restore, tienen que tomar en cuenta que al hacer la migración se crearon esquemas por cada rol y usuario en cada base de datos.

Esto podría estar bien para aquellos entornos en que manejen así la seguridad, pero podría crear ciertos "problemas" para los que no. Uno de ellos es que cada user al migrarse es el owner de su esquema y no se puede eliminar por lo mismo.

El error que marca es el siguiente: Msg 15138, Level 16, State 1, Line 1
The database principal owns a schema in the database, and cannot be dropped.

Por lo que es necesario que antes de querer eliminar el user, se cambie el owner del esquema o bien se elimine el esquema.

Cambiar el owner de un esquema es muy sencillo, solamente hay que ejecutar esto:
ALTER AUTHORIZATION ON SCHEMA::[nombre_del_esquema] TO DBO;

Es recomendable hacerlo, para evitar en una futura migración, en la que se borran y vuelven a crear los usuarios.

Un script que se puede utilizar para generar scripts que hagan el cambio de owner de todos los esquemas es el siguiente:

select 'ALTER AUTHORIZATION ON SCHEMA::['+ name + '] TO DBO;'
from sys.schemas where name not in ('dbo','sys','guest','INFORMATION_SCHEMA','db_accessadmin','db_backupoperator','db_datareader','db_datawriter','db_ddladmin','db_denydatareader','db_denydatawriter','db_owner','db_securityadmin')
and principal_id<>1 order by schema_id

Solamente hay que estar en cada una de las bases de datos y correr el script. Una vez que se haya hecho el cambio de owner en los esquemas, los esquemas se pueden eliminar o bien dejarlos en la base de datos.

Actualizando firmware de Smart Array E200i

2008-08-18T09:36:00.003-05:00

Hace poco estaba actualizando el firmware en un servidor Proliant BL460c G1 de HP.

En una de esas actualizaciones, actualizé el firmware de la tarjeta controladora de los arreglos (Smart Array E200i Controller) de la versión 1.66 a la versión 1.78, lo hice usando el exe que viene para servidores Windows 2003 a 32 bits, todo transcurrió normalmente, me conecté por la ILO y me di cuenta que al iniciar el servidor marcó unos mensaje y no encontró los discos duros y se pasó a la parte del PXE, así que le di un reboot nuevamente y ya pudo iniciar Windows.

Pero, al iniciar marcaba este mensaje: "A firmware update is needed for the physical drive with product ID GD072ABAB3 connected to array controller [Embedded]. The recommended minimum firmware revision should be HPDA." Obviamente no podía dejar el servidor así, ya que se iba a reinstalar y no quería que esto ocasionara problemas en el futuro.

Así que bajé el archivo .iso de la página de HP, con todos los firmware, utilizé el 7-zip para descomprimir el iso (y así no tener que quemar un CD), puse los archivos del iso en el servidor, ejecuté el el archivo CDBrowser, dentro del folder /compaq/CDBrowser, mediante la página del HomePage del servidor, chequé el modelo de los discos duros, en este caso DG072ABAB3, y en la sección de Device ahi estaba el modelo (SAS 72 GB 10K drives DG072ABAB3), desde la misma herramienta ejecuté el instalador y reinicié el servidor.

Cuando se estaba reiniciando el servidor detectó que estaba pendiente hacer un upgrade de versión de los discos y me presentaba 3 opciones, actualizar el porcentaje del update, dejar el update para el siguiente restart o cancelarlo, yo dejé que solo se actualizara y al cabo de unos 2 minutos, el update terminó y desaparecieron los mensajes de Warning.

Esto para tener en cuenta en un upgrade de versión de firmware de la tarjeta controladora de HP, la versión puede quedar muy arriba que puede ser que sea necesario actualizar los disco, lo que yo recomendaría sería primero actualizar el firmware de los discos duros, para evitar este tipo de sorpresas.

Mas scripts de SMO-SQL 2005 y PowerShell.

2008-08-12T15:01:00.006-05:00

En el último post expuse algunos scripts de PowerShell para obtener diferentes propiedades de los servidores SQL 2005. En este post voy a continuar explicando algunos otros que también son muy útiles en una política de Disaster Recover de SQL 2005.

El primer script servirá para obtener el script para recrear los usuarios de cada base de datos y agregarlos en su rol correspondiente.

param ( [string] $serverName )
$RutaScripts = "c\scripts\"
[void][reflection.assembly]::LoadWithPartialName("Microsoft.SqlServer.Smo")
$MyScripter=new-object ("Microsoft.SqlServer.Management.Smo.Scripter")
$srv=New-Object "Microsoft.SqlServer.Management.Smo.Server" $serverName
$MyScripter.Options.FileName = $f
$MyScripter.Options.AppendToFile = $true
$MyScripter.Server=$srv

write-host "Obteniendo el script para recrear los usuarios..."
foreach($db in $srv.databases) {
$f = [System.IO.Path]::Combine($RutaScripts, $nombre + "_Usuarios_" + $db.name + ".sql")
if ($db.Name -ne "master" -and $db.Name -ne "model" -and $db.Name -ne "msdb" -and $db.Name -ne "tempdb") {
$MyScripter.options.IncludeDatabaseContext = $true
foreach ($User in $db.Users) {
if ($User.Name -ne "sys" -and $User.Name -ne "dbo" -and $User.Name -ne "INFORMATION_SCHEMA" -and $User.Name -ne "guest") {
$MyScripter.Options.IncludeIfNotExists = $true
$MyScripter.Options.ScriptDrops = $true
$MyScripter.Script($User) | Out-file $f -append
}
if ($User.Name -ne "sys" -and $User.Name -ne "dbo" -and $User.Name -ne "INFORMATION_SCHEMA" -and $User.Name -ne "guest") {
$MyScripter.options.IncludeDatabaseContext = $false
$MyScripter.Options.IncludeDatabaseRoleMemberships = $true
$MyScripter.Options.ScriptDrops = $false
$MyScripter.Script($User) | Out-file $f -append
out-file -filePath $f -inputobject "`n" -append
}
}
}
}

El siguiente script sirve para obtener un script con los permisos de cada base de datos:
param ( [string] $serverName )
$RutaScripts = "c\scripts\"
[void][reflection.assembly]::LoadWithPartialName("Microsoft.SqlServer.Smo")
$MyScripter=new-object ("Microsoft.SqlServer.Management.Smo.Scripter")
$srv=New-Object "Microsoft.SqlServer.Management.Smo.Server" $serverName
$MyScripter.Options.FileName = $f
$MyScripter.Options.AppendToFile = $true
$MyScripter.Server=$srv

write-host "Obteniendo el script de permisos de cada base de datos..."
foreach($db in $srv.databases) {
if ($db.Name -ne "master" -and $db.Name -ne "model" -and $db.Name -ne "msdb" -and $db.Name -ne "tempdb") {
$f = [System.IO.Path]::Combine($RutaScripts, $nombre +"_permisos_" + $db.Name + ".sql")
out-file -filePath $f -inputobject "USE $db `nGO`n"
foreach ($permiso in $db.EnumObjectPermissions()| where {$_.Grantee.ToString() -ne 'public'} ) {
$var=[string]$permiso.PermissionState+" "+$permiso.PermissionType+" ON "+$permiso.Grantor+"."+$permiso.ObjectName+" TO "+$permiso.Grantee
out-file -filePath $f -inputobject $var -append
out-file -filePath $f -inputobject "GO" -append
}
}
}

En los siguientes posts estaré dando más tips para establecer políticas de Disaster Recovery para servidores SQL 2000 o 2005.

Utilizando PoweShell con SQL 2005 SMO.

2008-08-08T14:43:00.003-05:00

Ultimamente he estado utilizando PowerShell para ir creando un procedimiento para un Disaster Recovery Plan de SQL. En las siguientes entradas iré posteando información sobre como ir haciendo pequeños scripts que nos ayudarán para la administración de servidores SQL y como una herramienta para un DR.

Primeramente es necesario bajar de la página de Microsoft el PowerShell 1.0 y tener instaladas las herramientas de SQL 2005.

Es recomendable bajar la documentación del PowerShell de la misma página de Microsoft, la página que tiene The Mak en Database Journal es muy útil para ir aprendiendo de SQL 2005 con PowerShell, les estaré dando algunos ejemplos prácticos de cómo se puede utilizar como una herramienta para asegurar que se tiene un servidor backup de SQL listo para entrar en operación.

Una de las cosas que se tienen que asegurar siempre en un servidor es tener un respaldo de la configuración del servidor y de las bases de datos, así que voy a empezar con algunos ejemplos para obtener scripts de los servidores SQL.

Para correr los scripts solamente hay que guardar los scripts siguientes como archivo .ps1 y pasar de parámetro el nombre del servidor SQL con el quieren trabajar, por ejemplo: .\script1 "myserver".

Script para Recrear todos los jobs configurados en el servidor:

param (
[string] $serverName
)
$RutaScripts = "c:\scripts\"
void][reflection.assembly]::LoadWithPartialName("Microsoft.SqlServer.Smo")
$MyScripter=new-object ("Microsoft.SqlServer.Management.Smo.Scripter")
$MyScripter.Options.FileName = $f
$MyScripter.Options.AppendToFile = $true
$MyScripter.Server=$srv
$jobs=$srv.jobserver.jobs

write-host "Obteniendo el script para recrear los jobs..."
$f = [System.IO.Path]::Combine($RutaScripts, $nombre + "_jobs.sql")
out-file -filePath $f -inputobject "USE MASTER `nGO`n"
foreach ($job in $srv.jobserver.jobs) {
$MyScripter.Script($job) >> $f
out-file -filePath $f -inputobject "`n" -append
}

Con este script se obtiene en un archivo de texto todos los jobs configurados en el servidor, con este script se puede configurar un servidor de respaldo en segundos (solamente hay que cambiar la variable Enabled a 0)

Script para recrear todos los logins:
param (
[string] $serverName
)
$RutaScripts = "c:\scripts\"
void][reflection.assembly]::LoadWithPartialName("Microsoft.SqlServer.Smo")
$MyScripter=new-object ("Microsoft.SqlServer.Management.Smo.Scripter")
$MyScripter.Options.FileName = $f
$MyScripter.Options.AppendToFile = $true
$MyScripter.Server=$srv
write-host "Obteniendo el script para recrear los logins..."
$f = [System.IO.Path]::Combine($RutaScripts, $nombre + "_logins.sql")
out-file -filePath $f -inputobject "USE MASTER `nGO`n"
foreach($login in $srv.logins) {
$MyScripter.options.IncludeDatabaseContext = $true
$MyScripter.Options.IncludeIfNotExists = $true
$MyScripter.Options.ScriptDrops = $true
$MyScripter.Script($login) | out-file $f -append

$MyScripter.Options.IncludeIfNotExists = $true
$MyScripter.Options.ScriptDrops = $false
$MyScripter.Script($login) | out-file $f -append
out-file -filePath $f -inputobject "`n" -append
}

Este script es muy útil también cuando se está configurando un servidor de respaldo, obtiene todos los logins configurados, solamente hay que sustituir el password por el correcto y quitar la línea del disable, ya que por default SQL 2005 crea los logins deshabilitados.

Script para recrear todos los backup devices:
param (
[string] $serverName
)
$RutaScripts = "c:\scripts\"
void][reflection.assembly]::LoadWithPartialName("Microsoft.SqlServer.Smo")
$MyScripter=new-object ("Microsoft.SqlServer.Management.Smo.Scripter")
$MyScripter.Options.FileName = $f
$MyScripter.Options.AppendToFile = $true
$MyScripter.Server=$srv

out-file -filepath $ArchivoLog -inputobject "$hora Obteniendo el script para recrear los Backup Devices..." -append
write-host "Obteniendo el script para recrear los Backup Devices..."
$f = [System.IO.Path]::Combine($RutaScripts, $nombre + "_Backup_devices.sql")
out-file -filePath $f -inputobject "USE MASTER `nGO`n"

foreach($backup in $srv.backupdevices) {
$MyScripter.Script($backup) | out-file $f -append
out-file -filePath $f -inputobject "`n" -append
}

Con este script como se indica en la descripción se obtiene el script de todos los backup devices, con este script puedes instalar el servidor en segundos.

Script para recrear los linked servers:
param (
[string] $serverName
)
$RutaScripts = "c:\scripts\"
void][reflection.assembly]::LoadWithPartialName("Microsoft.SqlServer.Smo")
$MyScripter=new-object ("Microsoft.SqlServer.Management.Smo.Scripter")
$MyScripter.Options.FileName = $f
$MyScripter.Options.AppendToFile = $true
$MyScripter.Server=$srv

write-host "Obteniendo el script para recrear los linked servers..."
$f = [System.IO.Path]::Combine($RutaScripts, $nombre + "_linked.sql")
out-file -filePath $f -inputobject "USE MASTER `nGO`n"

foreach($linked in $srv.linkedservers) {
$MyScripter.options.IncludeDatabaseContext = $true
$MyScripter.Options.IncludeIfNotExists = $true
$MyScripter.Options.ScriptDrops = $true
$MyScripter.Script($linked) | out-file $f -append

$MyScripter.Options.IncludeIfNotExists = $true
$MyScripter.Options.ScriptDrops = $false
$MyScripter.Script($linked) | out-file $f -append
out-file -filePath $f -inputobject "`n" -append
}
Con este script se genera un script con el que se pueden crear todos los linked server, ojo, hay que recteclear el password y una vez creados cambiar la seguridad, ya que por default SQL los crea con: "Be made using the login's current security context".

En las siguientes posts iré publicando otros scripts que son útiles tambien para recrear usuarios, permisos y otras cosas.

Primer Post.

2008-08-08T12:13:00.000-05:00

Que tal,
En este blog estaré hablando de algunas cosas que suceden en el área de Informática, como puede ser algo de consejos para hacer tal o cual cosa con determinada herramienta o tal vez algo que haya aprendido recientemente y que quiera compartir con el mundo.

Principalmente estaré hablando de tecnología utilizada en las empresas en general, pero enfocada en servidores Windows y Linux.

Espero poco a poco ir aportando ideas y conocimiento en esta área, en la que nunca dejas de aprender cosas nuevas.