Diferencia entre revisiones de «PowerShell»

De Manuais Informática - IES San Clemente.
Ir a la navegación Ir a la búsqueda
 
(Página reemplazada por «>_»)
Etiqueta: Reemplazo
 
Línea 1: Línea 1:
== Introdución ==
>_
Windows PowerShell é unha interfaz de consola (CLI) con posibilidade de escritura e unión de comandos por medio de instruccións (''scripts''). É moito máis rica e interactiva que os seus predecesores, dende DOS ata Windows 7. Esta interfaz de consola está deseñada para o seu uso por parte de administradores de sistemas, có propósito de automatizar tarefas ou realizalas de forma máis controlada. Orixinalmente denominada como '''MONAD''' en 2003, o seu nome oficial cambiou ao actual cando foi lanzada ao público o 25 de abril de 2006.
 
=== Versións de Powershell ===
* '''PowerShell 1.0''': PowerShell 1.0 foi liberado en 2006 para o Windows XP SP2, Windows Server 2003 e Windows Vista. É un compoñente opcional para Windows Server 2008.
 
* '''PowerShell 2.0''': PowerShell 2.0 está integrado có Windows 7 e Windows Server 2008 R2 e é liberado para Windows XP con Service Pack 3, Windows Server 2003 con Service Pack 2 e Windows Vista con Service Pack 1.
: - PowerShell V2 inclúe cambios da linguaxe de scripting e a API do equipo, engadindo uns 240 cmdlets.
: - '''Windows PowerShell ISE v2.0''', é unha contorna de desenvolvemento para scripts PowerShell scripts PowerShell 2.0, está integrado no Windows 7 e no Windows Server 2008 R2 e é liberado para Windows XP có Service Pack 3, Windows Server 2003 có Service Pack 2 e Windows Vista có Service Pack 1.
* '''PowerShell 3.0''': PowerShell 3.0 está integrado no Windows 8 e no Windows Server 2012. Microsoft tamén fixo PowerShell 3.0 posible para Windows 7 có Service Pack 1, para Windows Server 2008 có Service Pack 1 e para Windows Server 2008 R2 có Service Pack 1.
: - PowerShell 3.0 é unha parte dun paquete moito máis grande, '''''Windows Management Framework'' 3.0 (WMF3)''', que tamén contén o servizo [https://technet.microsoft.com/en-us/library/cc781778(v=ws.10).aspx WinRM].
 
* '''PowerShell 4.0''': PowerShell 4.0 está integrado con Windows 8.1 e con Windows Server 2012 R2. Microsoft tamén fixo posible PowerShell 4.0 para Windows 7 SP1, Windows Server 2008 R2 SP1 e Windows Server 2012.
 
* '''PowerShell 5.0''': A revisión previa do PowerShell 5.0 estivo dispoñible con Windows Management Framework 5.0 (WMF5) en April de 2014.
: - Unha das novedades que introduce é [https://technet.microsoft.com/en-us/library/dn890706.aspx OneGet PowerShell cmdlets] para soportar o manexo de paquetes do repositorio [https://chocolatey.org/ Chocolatey].
: - En Agosto de 2015 Microsoft libera a última [https://www.microsoft.com/en-us/download/details.aspx?id=48729 actualización de PowerShell 5.0].
: - Windows 10 xa trae integrado
 
* '''PowerShell 5.1''':  Aparece coa Versión 1607 de Windows 10 (Anniversary Update) e en Windows 2016.
 
* '''PowerShell Core 6.0, 6.1 y 6.2''': Anunciada en Agosto do 2016.
: - PowerShell Core é unha PowerShell máis pequena que a PowerShell convencional e pode instalarse en sistemas operativos: MacOS e Linux, tamén en Windows.
: Con PowerShell Core, poderemos administrar e executar os mesmos scripts sobre os tres tipos de sistemas operativos: Windows MacOS e Linux como se foran un só.
 
* '''PowerShell 7''': Será a próxima versión de PowerShell.
: - Remprazará o PowerShell Core 6.x e a Windows PowerShell 5.1.
 
=== Sistemas Operativos e Versións de Powershell ===
Os Sistemas Operativos Windows e Windows Server están actualizando as súas versións de PowerShell:
* '''Windows PowerShell 4.0''' podemos atopalo no Windows 10, no Windows 8.1 e no Windows Server 2012 Release 2 (R2). Tamén é posible instalalo en equipos con Windows 7 with Service Pack 1 ou posteriores e Windows Server 2008 R2 con Service Pack 1 ou posteriores coa instalación do [https://www.microsoft.com/es-ES/download/details.aspx?id=40855 Windows Management Framework 4.0].
* '''Windows PowerShell 3.0''' podemos atopalo no Windows 8 e no Windows Server 2012. Tamén podemos instalalo en ordenadores que teñan Windows 7 có Service Pack 1 ou posteriores, Windows Server 2008 R2 có Service Pack 1 ou posteriores e Windows Server 2008 có Service Pack 2 ou posteriores coa instalación do [https://www.microsoft.com/en-us/download/details.aspx?id=34595 Windows Management Framework 3.0].
 
=== Executar Windows PowerShell ===
: Pulsar '''Tecla de Windows + R''' para que se execute "Executar", escribir '''''PowerShell''''' e pulsar '''''Enter'''''.
 
[[Imagen:powershell01.gif|700px]]
 
:* '''Executar Windows PowerShell como administrador''':
:# Crear un acceso directo no escritorio. Onde pon "Escriba a localización do elemento" escribimos simplemente "PowerShell" e pulsamos en "Seguinte".
:# Logo dámoslle un nome para este acceso directo como, por exemplo: "PowerShell como Administrador".
:# Para que se execute como Administrador, unha vez creado o acceso directo, facemos click sobre el có botón dereito e na ficha "Acceso directo" pulsamos no botón "Opcións avanzadas...".
 
[[Imagen:powershell02.gif|350px]]
 
Aparece unha nova fiestra na que temos que seleccionar a casiña de verificación "Executar como administrador", logo pulsamos en aceptar e xa temos preparado o acceso director para executar en calquera momento o PowerShell con privilexios de Administrador.
 
[[Imagen:powershell03.gif|250px]]
 
:* '''Executar Powershell como administrador dende liña de comandos:"
Para realizar esta tarefa emprégase o cmdlet [http://technet.microsoft.com/en-us/library/hh849848.aspx Start-Process].
<source lang="powershell">
# Abrir powershell como administrador:
PS> Start-Process Powershell -Verb RunAs
 
# Executar un script powershell como administrador:
PS> Start-Process Powershell -Verb RunAs -ArgumentList "-file c:\scripts\cambionome.ps1"
</source>
 
=== Coñecer a versión de PowerShell instalada no noso equipo ===
Para coñecer a versión instalada no noso equipo empregamos o comando: '''get-host'''
 
[[Imagen:powershell00.gif|700px]]
 
: Nesta imaxe vemos que a versión é a 2.0 (trátase dun Windows Server 2008).
 
[[Imagen:PowershellgethostW10.png|700px]]
 
: Nesta outra imaxe vemos que nun Windows 10 xa se atopa instalado o Powershell 5.0.
 
=== Configurar o equipo para executar scripts PowerShell ===
Antes de nada, debemos saber que:
* Os '''scripts''' de PowerShell son arquivos de texto gardados con extensión .PS1.
* Para crealos podemos empregar o propio Notepad ou, mellor, o software '''PowerShell ISE''' que se atopa xa instalado nos sistemas operativos Windows actuais. Tamén existen tamén ferramentas de terceiros como '''PowerGUI'''.
* Por defecto, para mellorar a seguridade, estes arquivos os abre o '''Notepad''' polo que, se lle decimos en '''Autologon''' que se executen o único que ocorre é que se "abren" sen mais (vese o contido). Se nos interesa, podemos configurar o Sistema Operativo Windows para que os arquivos con extensión '''.ps1''' se executen todos por defecto có programa '''Powershell.exe'''.
* Ademais, moitos deles, hai que executalos con permisos de Administrador (hai que baixar o nivel de “Notificación acerca de cambios en el equipo”, o '''UAC'''):
:: - [http://windows.microsoft.com/es-es/windows/turn-user-account-control-on-off#1TC=windows-7 Baixar UAC].
* Por último, hai que [http://technet.microsoft.com/es-es/library/dd347628.aspx cambiar a preferencia do usuario para a directiva de execución de Windows PowerShell], executando o comando:
<syntaxhighlight lang="powershell">
PS>Set-ExecutionPolicy RemoteSigned
</syntaxhighlight>
 
Para ver se cambiou o nivel executas o comando:
<syntaxhighlight lang="powershell">
PS>Get-ExecutionPolicy
</syntaxhighlight>
* Pódese axustar como o PS se comporta cando se produce un erro cando se executa código ou scripts. Para ver o modo actual empregaremos a variable [http://blogs.technet.com/b/heyscriptingguy/archive/2010/03/08/hey-scripting-guy-march-8-2010.aspx ErrorActionPreference]:
<syntaxhighlight lang="powershell">
PS>$ErrorActionPreference
Continue
</syntaxhighlight>
O modo por defecto vemos que é '''Continue''' que mostra os erros e continúa coa execución. Se queremos que non mostre os erros e tira para adiante teríamos que configuralo en '''SilentlyContinue'''.
<syntaxhighlight lang="powershell">
PS>$ErrorActionPreference = "SilentlyContinue"
</syntaxhighlight>
 
=== Mini-Introdución de manexo de PowerShell ===
*Executar Powershell:
:: No casiña de "buscar" de Windows teclear "PowerShell" e pulsar '''Intro'''.
* Executar Powershell como administrador:
<source lang="powershell">PS> Start-Process Powershell -Verb RunAs</source>
* Executar '''Powershell ISE''' para a creación de ''scripts''.
* Comprobar a versión de Powershell que estamos utilizando:
<source lang="powershell">PS> get-host</source>
* Configurar o equipo para executar ''scripts'' de PS realizados por nosotros e baixados de Internet (firmados):
<source lang="powershell">PS> Get-ExecutionPolicy
# Restricted
# AllSigned
# RemoteSigned
# Unrestricted
PS> Set-ExecutionPolicy RemoteSigned
</source>
* Los comandos de PS son denominados ahora ''cmdlets''.
* Exemplo típico cun ''cmdlet'' como [https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.utility/get-date?view=powershell-5.1 get-date]:
<source lang="powershell">PS> get-date
PS> get-help get-date
PS> get-date | fl
PS> get-date | fl day, hour, minute, second
PS> $fecha = get-date
PS> $fecha.gettype()
PS> $fecha.gettype().name
PS> $fecha
PS> $fecha | fl
PS> $fecha | get-member
PS> $fecha | get-member -MemberType Property
PS> $fecha.date
PS> $fecha | get-member -MemberType Method
PS> $fecha.date
PS> $fecha.AddDays(10)
</source>
* Ver de que comandos dispoñemos para traballar:
<source lang="powershell">PS> get-command -noun *date*
PS> Get-Command -CommandType cmdlet | Measure-Object -Line
PS> Get-Command -verb get | more
PS> Get-alias -Name rm
PS> get-alias | where {$_.Name -like "*m*"}
</source>
* Administración do sistema:
<source lang="powershell">
# Apagar o equipo
PS> Stop-Computer
# Reiniciar o equipo
PS> Restart-computer
</source>
* Información do sistema:
<source lang="powershell">
PS> DIR env:    # Directorio de variables de contorna
PS> $env:computername    # Nome de equipo
PS> $env:username    # Usuario que iniciou sesión
PS> Get-WmiObject -Class Win32_Computersystem    # Descubrir a configuración do equipo
</source>
 
== Cmdlets: entrada/saída básica ==
A diferencia da maioría das ferramentas de liñas de comandos, que aceptan e devolven texto, Windows PowerShell baséase en '''Microsoft .NET Framework''' e acepta e devolve obxectos de '''.NET Framework'''. Este cambio fundamental no contorno aporta ferramentas e métodos totalmente novos que melloran en grande medida o control, a eficiencia e a productividade de programadores e administradores.
 
'''Windows PowerShell''' é unha ferramenta de liña de comandos simple que introduce o concepto de '''cmdlet'''. Un '''cmdlet''' é unha combinación de verbo e nome que comprende un comando e un obxecto sobre o que actúa o comando. Os nomes de ''cmdlet'' de Windows PowerShell constan de verbos e nomes, separados por un guión (-), que en conxunto denotan as súas propiedades funcionáis. Por exemplo, o nome de ''cmdlet'' '''Get-Date''' combina o verbo (comando) "Get" có nombe (obxecto) "Date" para denominar ao ''cmdlet'' que recupera un obxecto ''Date'' especificado. Pode usar os ''cmdlets'' individualmente ou unilos como secuencias vinculadas para realizar tarefas complexas.
 
Os nomes de ''cmdlet'' toman parámetros como pares nome-valor que otorgan especificidade ao nome de ''cmdlet''. Cando se invocan, os ''cmdlets'' devolven obxectos de saída. Estes obxectos devoltos tamén teñen propiedades que se mostran como pares nome-valor. Debido a que os ''cmdlets'' devolven obxectos, estes últimos poden pasarse (ou "canalizarse") a outro ''cmdlet'', en secuencia. Deste xeito, os ''cmdlets'' poden encadenarse e proporcionar unha grande flexibilidade.
 
É importante ter en conta que un ''cmdlet'' non é un executable, senón que é unha sesión dunha clase de .NET Framework. Polo tanto, cunhas poucas excepcións, os ''cmdlets'' devolven obxectos en lugar de secuencias de texto e procesan os obxectos de entrada dunha canalización de obxectos.
 
No seguinte enlace vemos unha [http://technet.microsoft.com/en-us/library/hh849827.aspx colección de '''cmdlets'''] de mantemento moi interesantes e no seguinte unha colección de [http://technet.microsoft.com/en-us/library/hh849958.aspx utilidades ''cmdlets''].
 
Como pode verse, '''Windows PowerShell''' non é só unha ferramenta de liña de comandos. Tamén é, máis importante ainda, unha nova linguaxe de ''scripting''. Por exemplo, Windows PowerShell se instala de forma nativa en Windows 10 con '''496 ''cmdlets'''''. Outro exemplo é que Windows Server 2012 promocionado a Servidor de Dominio e no que tamén está instalado o servizo DNS, ten '''656 ''cmdlets'''''.
 
No seguinte enlace podemos atopar [http://technet.microsoft.com/en-us/library/hh847856.aspx axuda sobre os elmentos do núcleo de '''PowerShell'''].
 
* '''Por exemplo, se queres saber a data/hora actual:'''
<syntaxhighlight lang="powershell">
PS>get-date
miércoles, 19 de diciembre de 2012 14:50:30
</syntaxhighlight>
: Se queres ver a súa saída en formato '''lista''' (''Format-List''):
<syntaxhighlight lang="powershell">
PS>get-date | fl
...
</syntaxhighlight>
: Se queres ver a súa saída en formato '''táboa''' (''Format-Table''):
<syntaxhighlight lang="powershell">
PS>get-date | ft
...
</syntaxhighlight>
: Para ver todos os '''métodos''' e '''propiedades''' da clase ''get-date'' podemos redirixir a súa saída ao ''cmdlet'' '''get-member''':
<syntaxhighlight lang="powershell">
PS>get-date | get-member
...
</syntaxhighlight>
: Así, para ler algunha desas propiedades debemos facer o seguinte:
<syntaxhighlight lang="powershell">
PS>$data = get-date
PS>$data.year
2012
</syntaxhighlight>
: Por último, para ver a data en formato [http://www.epochconverter.com/ epoch]:
:: - [http://www.powershelladmin.com/wiki/Convert_windows_nanosecond_epoch_timestamp_to_human-readable_date_and_vice_versa Web moi interesante onde podemos ver como traballar có formato epoch].
<syntaxhighlight lang="powershell">
PS>$data = get-date -UFormat "%s"
PS>$data
1385854825,56271
</syntaxhighlight>
 
* Para mostrar por pantalla mensaxes emprégase o ''cmdlet'' '''Write-Host''':
<syntaxhighlight lang="powershell">
PS>Write-Host Hola, estamos no ano $data.year
Hola, estamos no ano 2012
#
# Para concatenar mellor facer así:
PS> Write-Host "Hola, estamos no ano $($data.year)"
Hola, estamos no ano 2012
</syntaxhighlight>
 
* Para pedir o valor dun parámetro ao usuario pode empregarse o ''cmdlet'' '''Read-Host''':
<syntaxhighlight lang="powershell">
PS>$nome = Read-Host "Introduce o teu nome: "
Introduce o teu nome: Manuel
PS> Write-Host "Hola $nome"
Hola Manuel
# En PowerShell o carácter de escape é "`" a comiña invertida ou ''backtick''
PS> Write-Host "Hola `$nome"
Hola $nome
</syntaxhighlight>
: Tamén podes poñelo todo nunha mesma liña:
<syntaxhighlight lang="powershell">
PS>$nome = Read-Host "Introduce o teu nome: "; Write-Host "Hola $nome"
Introduce o teu nome: Manuel
Hola Manuel
</syntaxhighlight>
 
* Para ver unha lista de todos os ''cmdlets'', ''aliases'', ''functions'', ''workflows'', ''filters'', ''scripts'' e ''applications'' dispoñibles utiliza: [http://technet.microsoft.com/es-es/library/hh849711.aspx Get-Command].
: Se queremos ver só os ''cmdlets'':
<syntaxhighlight lang="powershell">
#Ver a lista dos cmdlets:
PS>Get-Command -commandType cmdlet
...
#Contar o número de cmdlets existentes:
PS>Get-Command -commandType cmdlet | Measure-Object -Line
Lines ...
---
496
#Ver os cmdlets que realizan a acción "get":
PS>Get-Command -verb get
...
</syntaxhighlight>
 
* Para acceder á axuda utiliza [http://technet.microsoft.com/en-us/library/ee176848.aspx Get-Help].
<syntaxhighlight lang="powershell">
#Ver a axuda do cmdlet Get-Command:
PS>Get-Help Get-Command -detailed
...
#Descubrir comandos que realicen certas accións
#empregando "comodíns":
PS>Get-Command *help* -CommandType cmdlet
CommandType    Name        Definition
-----------    ----        ----------
cmdlet          Get-Help    Get-Help [[-Name] <String>] [-Path <String>] [-C...
</syntaxhighlight>
 
=== Agregar un novo módulo con máis cmdlets ===
: Podemos agregar un novo módulo que nos permita ter novos cmdlets. Vexamos un exemplo con cmdlets que nos permiten actualizar o sistema operativo. Trátase do módulo [https://gallery.technet.microsoft.com/scriptcenter/2d191bcd-3308-4edd-9de2-88dff796b0bc PSWindowsUpdate].
: Para instalalo hai que descargar o zip e descomprimilo nos directorios:
:: %USERPROFILE%\Documents\WindowsPowerShell\Modules
:: %WINDIR%\System32\WindowsPowerShell\v1.0\Modules
 
== Execución de ''scripts'' ==
PowerShell executa ''scripts'' con extensión '''.ps1''', de xeito que podes escribir todo o código nun arquivo de texto coa extensión indicada.
 
Para editar os ''scripts'' pódese utilizar un editor de texto calquera ou, mellor, a aplicación '''PowerShell ISE''' xa instalada nos Windows actuais. Tamén existen outras aplicacións como [http://powergui.org/index.jspa PowerGui], xa antes mencionada.
 
Para executar un ''script'' hai que indicar a súa dirección completa, isto podemos facelo de dous xeitos:
* Dende a liña de comandos convencional:
<syntaxhighlight lang="powershell">
powershell ./hola.ps1
powershell c:\scripts\hola.ps1
</syntaxhighlight>
* Dende a liña de comandos PowerShell:
<syntaxhighlight lang="powershell">
PS>./hola.ps1
PS>c:\scripts\hola.ps1
</syntaxhighlight>
 
== Comentarios ==
Os comentarios en PowerShell escríbense empregando o símbolo almofada ('''#'''). Todo o que se atope despois deste carácter, non será interpretado polo PowerShell.
<syntaxhighlight lang="powershell">
#Este é un comentario.
<#
 
Para
comentarios
multilínea
 
#>
</syntaxhighlight>
 
== Tipos de datos: variables, ''arrays'', listas e táboas ''hash'' ==
Neste apartado veremos como definir e traballar cós tipos de datos máis empregados en PowerShell.
 
=== Variables ===
As variables comezan por '''$''' e podemos meter nelas casi calquera “cousa”, por exemplo:
<syntaxhighlight lang="powershell">
#Obxecto DateTime
PS>$data = Get-Date
PS>$cadea.GetType().Name  #Ver o tipo de variable que é
DateTime
 
#Enteiro
PS>$numero = 1
PS>$numero.GetType().Name
Int32
 
#Decimal
PS>$numero_decimal = 6.5
PS>$numero_decimal.GetType().Name
Double
 
#String dunha única letra
PS>$letra = 'p'
PS>$letra.GetType().Name
String
 
#String de máis dun carácter
PS>$cadea = 'isto é unha cadea'
PS>$cadea.GetType().Name
String
</syntaxhighlight>
 
Para crear unha cadea de texto podemos facer referencia a outra variable:
<syntaxhighlight lang="powershell">
PS>$result = 1.50
PS>$texto = “O pan vale $result”
</syntaxhighlight>
 
Para acceder ao contido da variable só hai que poñer o seu nome e, como vimos agora, para crear un texto có contido de outra variable só temos que poñer esta entre comiñas dobres. Tede en conta que non se pode facer isto coas comiñas simples, pois estas non resolven variables.
<syntaxhighlight lang="powershell">
PS>$result = 1.50
PS>$texto = “O pan vale $result”
PS>$texto
O pan vale 1.50
</syntaxhighlight>
 
Podes sumar dúas variables numéricas ou unir dúas variables de texto:
<syntaxhighlight lang="powershell">
PS>$na = 1.50
PS>$nb= 3
PS>"$na + $nb = $($na + $nb)"
1.5 + 3 = 4,5
PS>$ta = "Ola"
PS>$tb = "amigo"
PS>$ta + $tb
Ola amigo
</syntaxhighlight>
 
Nunha variable tamén podemos gardar temporalmente a saída dun comandou ou dun ''cmdlet'':
<syntaxhighlight lang="powershell">
PS>$contido = Get-ChildItem c:\
PS>$contido
 
    Directorio: C:\
 
Mode                LastWriteTime    Length Name
----                -------------    ------ ----
d----        19/12/2012      1:28            inetpub
d----        14/07/2009      5:20            PerfLogs
d-r--        19/12/2012      1:28            Program
d-r--        19/12/2012      1:29            Program
d----        18/12/2012      0:24            scripts
d-r--        05/10/2011    15:05            Users
d----        19/12/2012      1:28            Windows
 
#Ver o tipo de elemento que é $contido
PS>$contido.GetType().name
Object[]
 
#Ver os métodos, propiedades, etc do obxecto $contido
PS>$contido | Get-Member
...
</syntaxhighlight>
 
: '''Nota:''' Debes ter en conta que en PowerShell as variables NON son sensibles a maiúsculas/minúsculas.
 
==== Atopar variables ====
Tamén é moi interesante saber que podemos atopar as variables xa definidas empregando a unidade virtual "'''variable:'''", vexamos algún exemplo:
<syntaxhighlight lang="powershell">
#Para mostrar todas as existentes
PS>Dir variable:
...
 
#Para mostrar todas as que comecen polas letras "nom":
PS>Dir variable:nom*
Name      Value
----      -----
nome2      Pepe
nome1      Xan
 
#Poñendo máis condicións:
PS>Dir variable:nom* -exclude *1*
Name      Value
----      -----
nome2      Pepe
 
#Para buscar unha variable polo valor que contén:
PS>dir variable: | Out-String -stream | Select-String " pepe "
nome2          pepe
</syntaxhighlight>
Neste último exemplo a saída de '''Dir''' é pasada a [http://technet.microsoft.com/en-us/library/hh849952.aspx Out-String] que convirte o resultado nun texto. O parámetro '''stream''' asegura que toda variable subministrada por '''Dir''' é separada unha a unha como texto. O ''cmdlet'' [http://technet.microsoft.com/en-us/library/hh849903.aspx Select-String] selecciona as liñas que inclúen o valor desexado, filtrando o resto. Para asegurarse que o valor da variable é "pepe" e non unha palabra que conteña ese conxunto de caracteres, introducimos uns espazos en branco antes e despois do buscado.
 
==== Verificar que unha variable existe ====
Se queremos verificar se unha variable existe podemos empregar o ''cmdlet'' [http://technet.microsoft.com/en-us/library/hh849776.aspx Test-Path]. Podemos ver uns exemplos:
<syntaxhighlight lang="powershell">
PS>$nome = "Andrea"
PS>Test-Path variable:\nome
True
PS>Test-Path variable:\apelido
False
</syntaxhighlight>
 
==== '''cmdlets''' específicos para traballar con variables ====
Existen cinco ''cmdlets'' específicos para traballar con variables:
Para conocelos podemos empregar o comando:
<syntaxhighlight lang="powershell">
PS> Get-Command -Noun variable
CommandType    Name                  ModuleName
-----------    ----                  ----------
Cmdlet          Clear-Variable        Microsoft.PowerShell.Utility
Cmdlet          Get-Variable          Microsoft.PowerShell.Utility
Cmdlet          New-Variable          Microsoft.PowerShell.Utility
Cmdlet          Remove-Variable        Microsoft.PowerShell.Utility
Cmdlet          Set-Variable          Microsoft.PowerShell.Utility
</syntaxhighlight>
* [http://technet.microsoft.com/es-es/library/hh849960.aspx Clear-Variable] : Limpa o contido da variable, polo que o contido desta pasa a ser '''NULL'''.
* [http://technet.microsoft.com/en-us/library/hh849899.aspx Get-Variable] : Obter o obxecto variable en si, non o valor da variable.
* [http://technet.microsoft.com/en-us/library/hh849913.aspx New-Variable] : Crear unha nova variable.
* [http://technet.microsoft.com/en-us/library/hh849935.aspx Remove-Variable] : Borra unha variable e o seu contido, sempre e cando esta non sexa unha constante ou unha variable creada polo sistema.
: Tamén podemos borrar unha variable como se tratase dun sistema de arquivos:
<syntaxhighlight lang="powershell">
PS>$nome = "Andrea"
PS>del variable:\nome
</syntaxhighlight>
* [http://technet.microsoft.com/en-us/library/hh849935.aspx Set-Variable] : Dalle un valor determinado a unha variable. Se a variable non existe créase.
 
==== Variable con descrición ====
As variables poden ter unha descrición opcional que nos axuda a atopala cando sexa preciso.
<syntaxhighlight lang="powershell">
PS>New-Variable dato -value 100 -description "variable de proba" -force
</syntaxhighlight>
Por outro lado, se mostramos esta variable vemos que esa propiedade aparece invisible a non ser que forcemos que o PowerShell a mostre:
<syntaxhighlight lang="powershell">
PS>$mivariable
100
PS>Dir variable:\mivariable
Name          Value
----          -----
mivariable    100
 
#Para mostrar a descrición:
PS>Dir variable:\mivariable | Format-Table Name, Value, Description -autosize
Name      Value  Description
----      -----  -----------
mivariable  100  variable de proba
 
#Tamén podemos aproveitar esa propiedade para buscar a variable:
PS> dir variable: | Format-Table Name, Value, Description | Out-String -stream | Select-String "proba"
mivariable        100              variable de proba
 
 
</syntaxhighlight>
 
==== Definindo constantes (variables protexidas) ====
Unha constante gardará un valor que non pode ser modificado. Traballan igual que as varibles pero con protección frente a escritura.
 
PowerShell non distingue entre unha variable e unha constane, pero nos ofrece seguridade frente a escritura. Vexamos como crealas:
<syntaxhighlight lang="powershell">
PS> New-Variable constante -value 100 -option ReadOnly
PS> $constante
100
PS> $constante = 200
No se puede sobrescribir la variable constante porque es de solo lectura o constante.
...
</syntaxhighlight>
 
Para cambiar o seu valor o mellor é eliminala e volver a creala, pero se intentamos iso precisaremos empregar a propiedade "'''-force'''":
<syntaxhighlight lang="powershell">
PS> del variable:\constante -force
PS> $constante
PS> $constante = "abc"
PS> $constante
abc
</syntaxhighlight>
 
==== Variables "Automáticas" ====
As "Variables Automáticas" son as que emprega PowerShell para o seu uso interno. Almacénanse no dispositivo '''variable:'''.
<syntaxhighlight lang="powershell">
PS> Dir variable: | Sort-Object Name | Format-Table Name, Description -autosize
 
Name                                    Description                           
----                                    -----------                           
$
?                                      Estado de ejecución del último comando.
^
_
args
ConfirmPreference                      Indica cuándo debe solicitarse confirma
                                        ción. Se solicita confirmación cuando e
                                        l valor de ConfirmImpact es igual o may
                                        or que el de $ConfirmPreference. Si $Co
                                        nfirmPreference es None, sólo se solici
                                        tará confirmación cuando se especifique
                                        el valor Confirm.
ConsoleFileName                        Nombre del archivo de consola actual.
DebugPreference                        Indica la acción tomada cuando se entre
                                        ga un mensaje de depuración.
Error
ErrorActionPreference                  Indica la acción tomada cuando se entre
                                        ga un mensaje de error.
ErrorView                              Indica el modo de vista que se debe usa
                                        r para mostrar los errores.
ExecutionContext                        Objetos de ejecución disponibles para l
                                        os cmdlets.
false                                  Boolean False
FormatEnumerationLimit                  Indica el límite de la enumeración al a
                                        plicar formato a los objetos de IEnumer
                                        able.
HOME                                    Carpeta que contiene el perfil del usua
                                        rio actual.
Host                                    Se trata de una referencia al host de e
                                        ste Runspace.
input
MaximumAliasCount                      Número máximo de alias permitidos en un
                                        a sesión.
MaximumDriveCount                      Número máximo de unidades permitidas en
                                        una sesión.
MaximumErrorCount                      Número máximo de errores para conservar
                                        en una sesión.
MaximumFunctionCount                    Número máximo de funciones permitidas e
                                        n una sesión.
MaximumHistoryCount                    Número máximo de objetos de historial p
                                        ara conservar en una sesión.
MaximumVariableCount                    Número máximo de variables permitidas e
                                        n una sesión.
mivariable                              variable de proba
MyInvocation
NestedPromptLevel                      Indica el tipo de confirmación que se d
                                        ebe mostrar para el nivel de anidación
                                        actual.
null                                    Las referencias a variables nulas siemp
                                        re devuelven el valor nulo. Las asignac
                                        iones no surten ningún efecto.
OutputEncoding                          La codificación de texto usada al canal
                                        izar texto hacia un ejecutable nativo.
PID                                    Id. de proceso actual.
PROFILE
ProgressPreference                      Indica la acción tomada cuando se entre
                                        gan registros de progreso.
PSBoundParameters
PSCulture                              Referencia cultural de la sesión de Win
                                        dows PowerShell actual.
PSEmailServer                          Variable para albergar el servidor de c
                                        orreo electrónico. Se puede usar en lug
                                        ar del parámetro HostName en el cmdlet
                                        Send-MailMessage.
PSHOME                                  Carpeta primaria de la aplicación host
                                        de este espacio Runspace.
PSSessionApplicationName                AppName donde se va a establecer la con
                                        exión remota.
PSSessionConfigurationName              Nombre de la configuración de sesión qu
                                        e se cargará en el equipo remoto.
PSSessionOption                        Opciones de sesión predeterminadas para
                                        las nuevas sesiones remotas.
PSUICulture                            Referencia cultural de la interfaz de u
                                        suario de la sesión de Windows PowerShe
                                        ll actual.
PSVersionTable                          Información de versión de la sesión de
                                        PowerShell actual.
PWD
ReportErrorShowExceptionClass          Especifica que los errores se muestren
                                        con una descripción de la clase de erro
                                        r.
ReportErrorShowInnerException          Especifica que se muestren los errores
                                        con las excepciones internas.
ReportErrorShowSource                  Especifica que los errores se muestren
                                        con el origen del error.
ReportErrorShowStackTrace              Especifica que los errores se muestren
                                        con el seguimiento de la pila.
ShellId                                El valor de ShellID identifica el shell
                                        actual. Lo usan las instrucciones #Req
                                        uires.
StackTrace
true                                    Boolean True
VerbosePreference                      Indica la acción tomada cuando se entre
                                        ga un mensaje detallado.
WarningPreference                      Indica la acción tomada cuando se entre
                                        ga un mensaje de advertencia.
WhatIfPreference                        Si su valor es true, se considera WhatI
                                        f como habilitado para todos los comand
                                        os.
</syntaxhighlight>
Para entender a súa función é moi interesante ler a súa descrición, pois as variables automáticas están moi ben documentadas.
 
==== Variables de entorno ====
As variables de entorno son unha fonte importante de información sobre o sistema operativo.
 
Para ler as variables de entorno hai que empregar '''$env''': diante do nome da variable de entorno desexada. Por exemplo, se queremos ler a dirección da carpeta de Windows farémolo do seguinte xeito:
<syntaxhighlight lang="powershell">
PS>$env:windir
C:\Windows
</syntaxhighlight>
Se queres ver todas as variables de entorno existentes en Windows:
<syntaxhighlight lang="powershell">
PS>DIR env:
 
Name                          Value
----                          -----
ALLUSERSPROFILE                C:\ProgramData
APPDATA                        C:\Users\Administrador\AppData\Roaming
CommonProgramFiles            C:\Program Files\Common Files
CommonProgramFiles(x86)        C:\Program Files (x86)\Common Files
CommonProgramW6432            C:\Program Files\Common Files
COMPUTERNAME                  WIN-3E2I6RMDDEA
ComSpec                        C:\Windows\system32\cmd.exe
FP_NO_HOST_CHECK              NO
HOMEDRIVE                      C:
HOMEPATH                      \Users\Administrador
LOCALAPPDATA                  C:\Users\Administrador\AppData\Local
LOGONSERVER                    \\WIN-3E2I6RMDDEA
NUMBER_OF_PROCESSORS          1
OS                            Windows_NT
Path                          %SystemRoot%\system32\WindowsPowerShell\v1.0\;C:\Windows\system32;C:\Windows;C:\Windo...
PATHEXT                        .COM;.EXE;.BAT;.CMD;.VBS;.VBE;.JS;.JSE;.WSF;.WSH;.MSC
PROCESSOR_ARCHITECTURE        AMD64
PROCESSOR_IDENTIFIER          Intel64 Family 6 Model 58 Stepping 9, GenuineIntel
PROCESSOR_LEVEL                6
PROCESSOR_REVISION            3a09
ProgramData                    C:\ProgramData
ProgramFiles                  C:\Program Files
ProgramFiles(x86)              C:\Program Files (x86)
ProgramW6432                  C:\Program Files
PSModulePath                  C:\Users\Administrador\Documents\WindowsPowerShell\Modules;C:\Windows\system32\Window...
PUBLIC                        C:\Users\Public
SESSIONNAME                    Console
SystemDrive                    C:
SystemRoot                    C:\Windows
TEMP                          C:\Users\ADMINI~1\AppData\Local\Temp
TMP                            C:\Users\ADMINI~1\AppData\Local\Temp
USERDOMAIN                    WIN-3E2I6RMDDEA
USERNAME                      Administrador
USERPROFILE                    C:\Users\Administrador
windir                        C:\Windows
windows_tracing_flags          3
windows_tracing_logfile        C:\BVTBin\Tests\installpackage\csilogfile.log
 
</syntaxhighlight>
 
==== Ámbito das variables ====
As variables de PowerShell teñen un ámbito que determina onde unha variable é accesible. Así, os ámbitos soportados son:
* '''''private''''' - A variable créase só no ámbito actual e non pasa a outros ámbitos. Por conseguinte, só pode ser lida e escrita no ámbito actual.
* '''''local''''' - A variable créase só no ámbito local. Este é o modo por defecto empregado sen ámbito. Estas variables pódense ler dende ámbitos originarios do ámbito de aplicación actual, pero non se poden modificar.
* '''''script''''' -  A variable será válida só no interior dun ''script'', pero válida en calquera lugar del. Por exemplo, unha variable así definida no interior dunha función será accesible dende calquera outra función existente no interior dese ''script''.
* '''''global''''' -  A variable será válida en calquera lugar, incluso fora das funcións e ''scripts''.
Estes ámbitos nos permiten restrinxir a visibilidade das variables en funcións ou ''scripts''.
Por defecto PowerShell fai unha '''"restrición automática"'''' do ámbito das variables, é dicir, se unha variable foi creada no interior dun ''script'' non será accesible dende a liña de comandos. Así e todo, se queremos que as variables do interior dun ''script'' sexan accesibles dende a consola só temos que poñer un '''.''' diante da chamada do ''script'':
<syntaxhighlight lang="powershell">
#Fíxate que poñemos un "punto", un espazo e logo chamamos o script:
PS>. C:\scripts\test.ps1
#Outro xeito de facelo se estamos no directorio onde se atopa o script:
PS>. .\test.ps1
#Logo da execución do script as variables definidas nel son accesibles dende a consola.
</syntaxhighlight>
Ollo! con este xeito de executar os ''scripts'' se este ten definidas "constantes".
 
Se queremos configurar ao noso antollo o ámbito das variables farémolo do seguinte xeito:
<syntaxhighlight lang="powershell">
PS>$private:test1 = 100
PS>$local:test2 = 200
PS>$script:test3 = 300
PS>$global:test4 = 400
</syntaxhighlight>
 
==== Tipos de varibles ====
PowerShell configura automáticamente o tipo de variable dependendo do dato gardado nela. Nun principio, nós non temos que facer nada.
Saber que có comando '''GetType().Name''' podemos verificar o tipo de variable do que se trata. E tamén, tede en conta que podemos facer isto mesmo empregando "un valor" directamente:
<syntaxhighlight lang="powershell">
#Directamente con DATOS:
PS> (12).GetType().Name
Int32
PS> (12.5).GetType().Name
Double
PS> ("H").GetType().Name
String
PS> (Get-Date).GetType().Name
DateTime
#Definir unha variable e logo ver o tipo que PS lle asigna:
PS> $numero = 100
PS> $numero.GetType().Name
Int32
</syntaxhighlight>
Algúns dos tipos de variables cós que pode traballar PowerShell son os seguintes:
{| border="1" cellspacing="0" cellpadding="5"
 
! style="background:#ffdead;" | Tipo de Variable
! style="background:#ffdead;" | Descrición
! style="background:#ffdead;" | Exemplo
|-
| '''[array]'''
| Un vector
|
|-
| '''[bool]'''
| Valor Si-Non
| <syntaxhighlight lang="powershell">
[bool]$test = $true
</syntaxhighlight>
|-
| '''[byte]'''
| Enteiro sen signo, 0...255
| <syntaxhighlight lang="powershell">
[byte]$valor = 12
</syntaxhighlight>
|-
| '''[char]'''
| Carácter Unicode individual
| <syntaxhighlight lang="powershell">
[bool]$letra = "a"
</syntaxhighlight>
|-
| '''[datetime]'''
| Data e Hora
| <syntaxhighlight lang="powershell">
[datetime]$data = "24.Dec 2012 12:30"
</syntaxhighlight>
|-
| '''[decimal]'''
| Número decimal
| <syntaxhighlight lang="powershell">
[decimal]$num = 12
</syntaxhighlight>
|-
| '''[double]'''
| Decimal punto flotante de doble precisión
| <syntaxhighlight lang="powershell">
[double]$numero = 12.45
</syntaxhighlight>
|-
| '''[guid]'''
| Número de identificación único de 32 bytes
|
|-
| '''[hashtable]'''
| Táboa hash
|
|-
| '''[int16]'''
| Enteiro con caracteres de 16 bits
| <syntaxhighlight lang="powershell">
[int16]$test = 1000
</syntaxhighlight>
|-
| '''[int32]'''
'''[int]'''
| Enteiro con caracteres de 32 bits
| <syntaxhighlight lang="powershell">
[int32]$test = 5000
</syntaxhighlight>
|-
| '''[int64]'''
'''[long]'''
| Enteiro con caracteres de 64 bits
| <syntaxhighlight lang="powershell">
[int64]$test = 4GB
</syntaxhighlight>
|-
| '''[nullable]'''
| Ensancha outro tipo de datos para engadirlles a capacidade de conter valores nulos. Pódese empregar, entre outros casos, para aplicar algún parámetro opcional
|
|-
| '''[psobject]'''
| Obxecto PowerShell
|
|-
| '''[regex]'''
| Expresión regular
| <syntaxhighlight lang="powershell">
$texto = "Ola mundo"
[regex]::split($texto, "la")
</syntaxhighlight>
|-
| '''[sbyte]'''
| Enteiro con caracteres de 8 bits
| <syntaxhighlight lang="powershell">
[sbyte]$valor = -12
</syntaxhighlight>
|-
| '''[scriptblock]'''
| Bloque de código de PowerShell
|
|-
| '''[single]'''
'''[float]'''
| Decimal punto flotante de simple precisión
| <syntaxhighlight lang="powershell">
[single]$num = 44.76
</syntaxhighlight>
|-
| '''[string]'''
| String
| <syntaxhighlight lang="powershell">
[string]$texto = "Ola"
</syntaxhighlight>
|-
| '''[switch]'''
| Parámetro de tipo "switch"
|
|-
| '''[timespan]'''
| Intervalo de tiempo
| <syntaxhighlight lang="powershell">
PS> [timespan]$t = New-TimeSpan $(Get-Date)"1.Sep 07"
PS> $t
Days              : -1944
Hours            : -14
Minutes          : -43
Seconds          : -17
Milliseconds      : -907
</syntaxhighlight>
|-
| '''[type]'''
| Type
|
|-
| '''[uint16]'''
| Enteiro sen signo de 16 bits
| <syntaxhighlight lang="powershell">
[uint16]$value = 1000
</syntaxhighlight>
|-
| '''[uint32]'''
| Enteiro sen signo de 32 bits
| <syntaxhighlight lang="powershell">
[uint32]$value = 1000
</syntaxhighlight>
|-
| '''[uint64]'''
| Enteiro sen signo de 64 bits
| <syntaxhighlight lang="powershell">
[uint64]$value = 1000
</syntaxhighlight>
|-
| '''[xml]'''
| Documento XML
|
|-
 
|}
 
PowerShell nos permite asignar o tipo de varible que imos gardar, farémolo poñendo diante da definición dela o tipo que nos interese gardar:
<syntaxhighlight lang="powershell">
PS> [string]$test = 100
PS> $test
100
PS> $test.GetType().Name
String
</syntaxhighlight>
 
Para convertir o tipo de varible temos que facer así:
<syntaxhighlight lang="powershell">
PS> $num = 5000
PS> $num.GetType().Name
Int32
PS> $texto = [string]$num
PS> $texto
5000
PS> $texto.GetType().Name
String
</syntaxhighlight>
 
Có seguinte exemplo vemos as vantaxes de empregar tipos de variables especializadas:
<syntaxhighlight lang="powershell">
#Se non especificamos nada a seguinte variable será un string:
PS> $date.GetType().Name
String
PS> $date = "Diciembre 24, 2012"
PS> $date
Diciembre 24, 2012
PS> $date.AddDays(60)
Error en la invocación del método porque [System.String] no contiene ningún método llamado 'AddDays'.
En línea: 1 Carácter: 14
+ $date.AddDays <<<< (60)
    + CategoryInfo          : InvalidOperation: (AddDays:String) [], RuntimeException
    + FullyQualifiedErrorId : MethodNotFound
#Vemos que non nos permite empregar métodos específicos das variables de tipo "datetime"
#Borramos a variable e a volvemos a crear pero especificando que é do tipo desexado:
PS> del variable:\date
PS> [datetime]$date = "December 24, 2012"
PS C:\Users\Administrador> $date
 
lunes, 24 de diciembre de 2012 0:00:00
 
 
PS C:\Users\Administrador> $date.AddDays(60)
 
viernes, 22 de febrero de 2013 0:00:00
#Vemos que agora si podemos empregar os métodos específicos...
</syntaxhighlight>
 
=== Arrays ===
Un ''array'' é unha variable que pode conter calquera número de elementos de calqueira tipo.
O primeiro elemento ten a posición '''0''', indicándose estes '''separados por comas'''. Vexamos un exemplo:
<syntaxhighlight lang="powershell">
PS> $data = Get-Date
PS> $data
 
viernes, 28 de diciembre de 2012 20:02:34
 
PS> $numero = 25.40
PS> $numero
25,4
PS> $letra = "a"
PS> $letra
a
PS> $array = $data, "Ola mundo", $numero, $letra
PS> $array
 
viernes, 28 de diciembre de 2012 20:02:34
Ola mundo
25,4
a
 
PS>$array.GetType().Name
Object[]
 
#Outro xeito de crear un array:
PS>$array2 = @(1,2,3,"Hello")
#Crear un array baleiro:
PS>$array3 = @()
#Comprobar o tamaño actual do array:
PS> $array3.length
0
#Agregar un elemento ao array:
PS> $array3 += "Novo elemento"
PS> $array3.length
1
PS> $array3
Novo elemento
</syntaxhighlight>
Como se comentou antes, os elementos dun ''array'' numéranse dende cero, e se pode acceder a calquera elemento indicando a súa posición entre corchetes '''[]'''.
<syntaxhighlight lang="powershell">
PS> $array[2]
25,4
</syntaxhighlight>
Para seleccionar varios elementos á vez:
<syntaxhighlight lang="powershell">
PS> $array[0,2]
viernes, 28 de diciembre de 2012 20:02:34
25,4
</syntaxhighlight>
Tamén se pode ver un rango de elementos indicando a posición de inicio e a de fin:
<syntaxhighlight lang="powershell">
PS> $array[1..3]
Ola mundo
25,4
a
</syntaxhighlight>
A posición do último elemento é '''-1''':
<syntaxhighlight lang="powershell">
PS> $array[-1]
a
</syntaxhighlight>
E, tamén dicir, que podemos ver o número de elementos dun ''array'' có método '''.count'''.
<syntaxhighlight lang="powershell">
PS> $array.count
4
</syntaxhighlight>
 
'''A saída dun comando, aínda que nos pareza texto plano, é en realidade un ''array''.''' Vexamos un exemplo:
<syntaxhighlight lang="powershell">
#Gardamos o contido do comando ipconfig:
PS> $ip = ipconfig
#Comprobamos que se gardou:
PS> $ip
 
Configuración IP de Windows
 
Adaptador de Ethernet Conexión de área local:
  Sufijo DNS específico para la conexión. . : Home
  Vínculo: dirección IPv6 local. . . : fe80::84a9:ca57:4483:3184%11
  Dirección IPv4. . . . . . . . . . . . . . : 10.0.2.15
  Máscara de subred . . . . . . . . . . . . : 255.255.255.0
  Puerta de enlace predeterminada . . . . . : 10.0.2.2
...
#Vemos se PowerShell creou un Array:
PS> $ip -is [Array]
True
#Calculamos o número de elementos do Array:
PS> $ip.Count
23
#Mostramos os elementos 7 e 8:
PS> $ip[7]
  Vínculo: dirección IPv6 local. . . : fe80::84a9:ca57:4483:3184%11
PS> $ip[8]
  Dirección IPv4. . . . . . . . . . . . . . : 10.0.2.15
</syntaxhighlight>
Se algún comando se garda en texto plano e queremos forzar que se garde nun ''array'' empregaremos o constructor '''@()''':
<syntaxhighlight lang="powershell">
#Borramos a variable $ip antes creada
PS> del variable:\ip
#Forzamos a que a saída do comando ipconfig se garde nun array:
PS> $ip = @(ipconfig)
</syntaxhighlight>
 
=== Listas ===
Unha lista é un ''array'' dinámico no que se poden engadir e eliminar elementos dun xeito moi fácil.
Para definir unha lista baleira:
<syntaxhighlight lang="powershell">
PS> $lista = New-Object System.Collections.ArrayList
</syntaxhighlight>
Pódese ver que é un elemento '''ArrayList''' de .NET.
Para engadir elementos de calquera tipo emprégase o método ''.add'':
<syntaxhighlight lang="powershell">
PS> $lista.add("cadea")
0
PS> $lista.add(45)
1
PS> $data = Get-date
PS> $lista.add($data)
2
PS> $lista.add("outra cadea")
3
PS> $lista.add(450)
4
 
#Para visualizar o seu contido:
PS> $lista
cadea
45
lunes, 31 de diciembre de 2012 4:37:51
outra cadea
450
</syntaxhighlight>
Para eliminar elementos empregamos ''.remove'', ''.removerange'' e ''removeat'':
<syntaxhighlight lang="powershell">
#Eliminar un elemento dado o seu contido:
PS> $lista.remove(45)
PS> $lista
cadea
lunes, 31 de diciembre de 2012 4:37:51
outra cadea
450
 
#Eliminar un rango de elementos:
PS> $lista.removerange(2,2)
PS> $lista
cadea
lunes, 31 de diciembre de 2012 4:37:51
 
#Eliminar un único elemento:
PS> $lista.removeat(0)
PS> $lista
lunes, 31 de diciembre de 2012 4:37:51
</syntaxhighlight>
E, por último, indicar que, para eliminar todo o contido da lista e deixala baleira empregamos ''.clear'':
<syntaxhighlight lang="powershell">
PS> $lista.clear()
</syntaxhighlight>
 
=== Táboas ''hash'' ===
As táboas ''hash'' gardan '''"pares chave-valor"'''.
Para crear un ''hash'' baleiro:
<syntaxhighlight lang="powershell">
PS> $hash = @{}
</syntaxhighlight>
Pódense engadir pares chave-valor de calquera tipo:
<syntaxhighlight lang="powershell">
PS> $hash["primeiro"] = 1
PS> $hash["data"] = $data
PS> $hash["taboa"] = 1,"dous",3,4.5
PS> $hash[2] = "dous"
</syntaxhighlight>
Coma sempre, para ver o contido:
<syntaxhighlight lang="powershell">
PS> $hash
Name                          Value
----                          -----
data                          31/12/2012 4:37:51
taboa                          {1, dous, 3, 4,5}
2                              dous
primeiro                      1
</syntaxhighlight>
Para acceder ao valor dun elemento (chave), hai que indicar o nome do ''hash'' seguido dun punto e o nome da chave:
<syntaxhighlight lang="powershell">
PS> $hash.primeiro
1
PS> $hash.data
lunes, 31 de diciembre de 2012 4:37:51
PS> $hash.taboa
1
dous
3
4,5
PS> $hash.2
Erro...
</syntaxhighlight>
Vemos que aquí temos un erro pois a chave é un número. Isto soluciónase indicando a chave do elemento entre corchetes:
<syntaxhighlight lang="powershell">
PS> $hash[2]
dous
</syntaxhighlight>
Se as chaves son de tipo cadea tamén poden ir entre corchetes, pero, neste caso, a chave ten que ir entre comiñas:
<syntaxhighlight lang="powershell">
PS> $hash["data"]
lunes, 31 de diciembre de 2012 4:37:51
</syntaxhighlight>
É posible acceder só as chaves do ''hash'':
<syntaxhighlight lang="powershell">
PS> $hash.keys
data
taboa
2
primeiro
</syntaxhighlight>
E tamén só aos valores:
<syntaxhighlight lang="powershell">
PS> $hash.values
lunes, 31 de diciembre de 2012 4:37:51
1
dous
3
4,5
dous
1
</syntaxhighlight>
Como un dos valores gardados é unha táboa, é posible acceder a cada un dos valores de dita táboa:
<syntaxhighlight lang="powershell">
PS> $hash.taboa[0]
1
</syntaxhighlight>
Para eliminar un dos elementos do ''hash'':
<syntaxhighlight lang="powershell">
PS> $hash.remove("data")
PS> $hash
 
Name                          Value
----                          -----
taboa                          {1, dous, 3, 4,5}
2                              dous
primeiro                      1
</syntaxhighlight>
E para "limpar" todo o ''hash'':
<syntaxhighlight lang="powershell">
PS> $hash.clear()
PS> $hash
</syntaxhighlight>
 
== Obxectos ==
PowerShell traballa con obxectos, pero nos só vemos texto pois PowerShell "convirte" automáticamente eses obxectos en "texto".
 
Un obxecto non é máis que a suma de '''Propiedades''' e '''Métodos'''.
 
Se queremos ver as Propiedades e os Métodos dun obxecto empregaremos o ''cmdlet'' '''Get-Member'''. Vexamos como ver só as propiedades de, por exemplo, unha cadea de texto:
<syntaxhighlight lang="powershell">
# Definimos a variable $cadea
PS> $cadea = "Ola caracola"
PS> $cadea
Ola caracola
 
# Listamos só as Propiedades:
PS> $cadea | Get-Member -memberType property
 
  TypeName: System.String
 
Name  MemberType Definition
----  ---------- ----------
Length Property  System.Int32 Length {get;}
 
# Listamos só os Métodos:
PS> $cadea | Get-Member -memberType method
 
  TypeName: System.String
 
Name            MemberType Definition
----            ---------- ----------
Clone            Method    System.Object Clone()
CompareTo        Method    int CompareTo(System.Object value), int CompareTo(string strB)
Contains        Method    bool Contains(string value)
CopyTo          Method    System.Void CopyTo(int sourceIndex, char[] destination, int destinationIndex, int count)
EndsWith        Method    bool EndsWith(string value), bool EndsWith(string value, System.StringComparison compari...
Equals          Method    bool Equals(System.Object obj), bool Equals(string value), bool Equals(string value, Sys...
GetEnumerator    Method    System.CharEnumerator GetEnumerator()
GetHashCode      Method    int GetHashCode()
GetType          Method    type GetType()
GetTypeCode      Method    System.TypeCode GetTypeCode()
IndexOf          Method    int IndexOf(char value), int IndexOf(char value, int startIndex), int IndexOf(char value...
IndexOfAny      Method    int IndexOfAny(char[] anyOf), int IndexOfAny(char[] anyOf, int startIndex), int IndexOfA...
Insert          Method    string Insert(int startIndex, string value)
IsNormalized    Method    bool IsNormalized(), bool IsNormalized(System.Text.NormalizationForm normalizationForm)
LastIndexOf      Method    int LastIndexOf(char value), int LastIndexOf(char value, int startIndex), int LastIndexO...
LastIndexOfAny  Method    int LastIndexOfAny(char[] anyOf), int LastIndexOfAny(char[] anyOf, int startIndex), int ...
Normalize        Method    string Normalize(), string Normalize(System.Text.NormalizationForm normalizationForm)
PadLeft          Method    string PadLeft(int totalWidth), string PadLeft(int totalWidth, char paddingChar)
PadRight        Method    string PadRight(int totalWidth), string PadRight(int totalWidth, char paddingChar)
Remove          Method    string Remove(int startIndex, int count), string Remove(int startIndex)
Replace          Method    string Replace(char oldChar, char newChar), string Replace(string oldValue, string newVa...
Split            Method    string[] Split(Params char[] separator), string[] Split(char[] separator, int count), st...
StartsWith      Method    bool StartsWith(string value), bool StartsWith(string value, System.StringComparison com...
Substring        Method    string Substring(int startIndex), string Substring(int startIndex, int length)
ToCharArray      Method    char[] ToCharArray(), char[] ToCharArray(int startIndex, int length)
ToLower          Method    string ToLower(), string ToLower(System.Globalization.CultureInfo culture)
ToLowerInvariant Method    string ToLowerInvariant()
ToString        Method    string ToString(), string ToString(System.IFormatProvider provider)
ToUpper          Method    string ToUpper(), string ToUpper(System.Globalization.CultureInfo culture)
ToUpperInvariant Method    string ToUpperInvariant()
Trim            Method    string Trim(Params char[] trimChars), string Trim()
TrimEnd          Method    string TrimEnd(Params char[] trimChars)
TrimStart        Method    string TrimStart(Params char[] trimChars)
 
</syntaxhighlight>
 
== Control de fluxo: condicións e bucles ==
=== Condicións ===
* '''If'''
Coma na maioría das linguaxes, [http://www.powershellpro.com/powershell-tutorial-introduction/powershell-tutorial-conditional-logic/ if] encárgase de avaliar e comparar casi todo. PowerShell emprega a estrutura básica: '''if (condición) {acción}''' e tamén admite '''else''' e '''elseif'''. Vexamos algún exemplo:
<syntaxhighlight lang="powershell">
$linguaxe = "galego"
 
if ($linguaxe -eq "aleman")
{
"A linguaxe é alemán."
}
elseif ($linguaxe -eq "francés")
{
"A linguaxe é francés."
}
else
{
"A linguaxe non é nin alemán nin francés."
}
 
exit 0
</syntaxhighlight>
 
Esta estrutura de avaliación de condicións sempre comeza con '''if''', logo os '''elseif''' que se precisen e, por último, '''else''', dependendo do camiño que queiras seguir. Neste exemplo, como '''$linguaxe''' non é nin "francés" sin "alemán", toma a acción de '''else'''.
 
Os [http://technet.microsoft.com/en-us/library/hh847759.aspx operadores de comparación] máis importantes:
{| border="1" cellspacing="0" cellpadding="5"
! style="background:#ffdead;" | Operador
! style="background:#ffdead;" | Explicación
|-
| '''-eq'''
| igual que
|-
| '''-gt'''
| maior que
|-
| '''-ge'''
| maior ou igual que
|-
| '''-lt'''
| menor que
|-
| '''-le'''
| menor ou igual que
|-
| '''-ne'''
| distinto que
|-
| '''-like'''
| parecido a (admite '''*''' como comodín)
|-
| '''-notlike'''
| non parecido a (admite '''*''' como comodín)
|-
| '''-match'''
| comprobar se existe unha cadea no interior de outra (admite expresións regulares)
|-
 
|}
 
Podemos ver un exemplo máis antes de seguir, nel compróbase a existencia dun arquivo compartido nun servidor e, se existe, este arquivo se executa coa aplicación de Windows predefinida para a súa extensión:
<syntaxhighlight lang="powershell">
$servidor = "server00"
if (Test-path -path "\\$servidor\netlogon\aviso.html")
{
Invoke-Item "\\$servidor\netlogon\aviso.html"
}
</syntaxhighlight>
 
Poden avaliarse dúas ou máis condicións cós operadores lóxicos '''and''' e '''or''':
<syntaxhighlight lang="powershell">
if  ( ( $linguaxe -ne "alemán" ) -and ( $linguaxe -ne "francés" ) )
</syntaxhighlight>
Neste exemplo téñense que cumprir as dúas condicións ao redor de '''and''', e hai que fixarse que todo debe ir dentro de paréntese.
 
 
* '''Switch'''
Se hai que avaliar moitas condicións á vez, é máis cómodo empregar '''switch'''. Vexamos un exemplo:
<syntaxhighlight lang="powershell">
$linguaxe = "galega"
 
switch ($linguaxe)
{
"galega" {"A linguaxe é galega."}
"francés" {"A linguaxe é francés."}
"alemán" {"A linguaxe é alemán."}
"inglés" {"A linguaxe é inglés."}
"italiano" {"A linguaxe é italiano."}
"español" {"A linguaxe é español."}
"danés" {"A linguaxe é danés."}
default {"A linguaxe non está rexistrada."}
}
 
exit 0
</syntaxhighlight>
 
* '''Where'''
Como vimos antes, podemos redirixir a saída dun ''cmdlet'', obxecto ou colección de cousas por unha tubería e acceder as súas propiedades. Moitas veces necesitamos atopar algunha porpiedade concreta con algún valor concreto, e aquí é onde empreamos '''where'''. Vexamos un exemplo:
<syntaxhighlight lang="powershell">
PS> Get-Date
miércoles, 02 de enero de 2013 16:15:25
 
PS> Get-Date | where {$_.year -eq 2012}
PS> Get-Date | where {$_.year -eq 2013}
miércoles, 02 de enero de 2013 16:16:01
</syntaxhighlight>
Como vemos aquí, aparece a variable especial '''$_'''. Así que '''Where''' toma a saída do ''cmdlet'' e avalía o que aparece a continuación entre chaves. '''$_''' realmente é a saída de '''get-date''', e '''$_.year''' é a propiedade ano de '''get-date'''. Despois, o operador '''-eq''' indica se '''$_.year''' é igual a 2012 na primeira e 2013 na segunda. Se se cumple a condición, devolve a saída en si como o faría '''get-date''', e en caso contrario non devolve nada.
 
=== Bucles ===
PowerShell implementa 5 tipos de bucles: '''foreach''', '''for''', '''while''', '''do-while''' e '''do-until'''. Funcionan con táboas, listas, ''hashes'' e calquera cousa que conteña unha colección de elementos.
* '''Foreach'''
É o máis sinxelo de usar, pois fai un percorrido directo por todos os elementos que lle des, por exemplo unha táboa:
<syntaxhighlight lang="powershell">
$taboa = 1, 'dous', 3, 'catro', 5
 
foreach ($elemento in $taboa) {$elemento}
 
exit 0
</syntaxhighlight>
Como pode verse, '''foreach''' crea un '''$elemento''' por cada elemento de '''$taboa''' e despois, entre chaves, podes facer calquera cousa con dito elemento, neste caso o único que se fai é mostralo.
 
* '''For'''
Crea e inicializa unha variable índice, avalía unha condición con esa variable e despois a incrementa se se cumple a condición.
<syntaxhighlight lang="powershell">
PS> for ($i=1; $i -le 5; $i++) {$i}
1
2
3
4
5
</syntaxhighlight>
 
* '''While'''
É igual que un '''For''' e tamén avalía a condición ao principio do bucle, pero non ten en conta nin a creación da variable índice nin o seu incremento.
<syntaxhighlight lang="powershell">
PS> $i = 1
PS> while ($i -le 5) {$i; $i++}
1
2
3
4
5
</syntaxhighlight>
Tamén pode ser a avaliación dunha cadea:
<syntaxhighlight lang="powershell">
PS> $cadea = ""
PS> while ($cadea -ne "correcto") {$cadea = read-host "Contrasinal: "}
Contrasinal: : cousa
Contrasinal: : abc123.
Contrasinal: : correcto
PS>
</syntaxhighlight>
 
* '''Do-While'''
Igual que '''While''' pero avalía a condición ao final de cada bucle. Vexamos un exemplo:
<syntaxhighlight lang="powershell">
$cadea = ""
do
{
$cadea  = Read-Host "Contrasinal"
}
while ($cadea -ne "correcto")
 
exit 0
</syntaxhighlight>
 
* '''Do-Until'''
Funciona exactamente igual que '''Do-While''' pero cambia a lóxica. '''Do-While''' da voltas mentres se produza a condición e '''Do-Until''' da voltas ata que se produza a condición. Vexamos un exemplo:
<syntaxhighlight lang="powershell">
$cadea = ""
do
{
$cadea  = Read-Host "Contrasinal"
}
until ($cadea -eq "correcto")
 
exit 0
</syntaxhighlight>
 
=== Bucles especiais===
Pódese obter unha enumeración rápida do seguinte xeito:
<syntaxhighlight lang="powershell">
PS> 1..5
1
2
3
4
5
</syntaxhighlight>
Se rediriximos esa saída por unha tubería, cada elemento da enumeración sae da tubería como a variable '''$_''' e podemos facer algo con iso, como por exemplo multiplicalo por 5:
<syntaxhighlight lang="powershell">
PS> 1..5 | %{$_ * 5}
5
10
15
20
25
</syntaxhighlight>
 
== Funcións ==
Existen varias formas de definir funcións en PowerShell, vexamos a máis sinxela:
<syntaxhighlight lang="powershell">
PS> function suma($x,$y) {$resultado = $x + $y; return $resultado}
PS> suma 2 3
5
PS>
</syntaxhighlight>
Defínese a función suma que toma como parámetros as variables '''$x''' e '''$y''' (entre paréntese). A continuación, entre chaves fai algo con elas (neste caso as suma, coloca a solución en '''$resultado''' e devolve '''$resultado''').
A chamada á función é simple: escríbese o nome da función e, a continuación, indícanse os parámetros.
 
É interesante saber que tamén podemos crear unha variable có resultado da chamada á función:
<syntaxhighlight lang="powershell">
PS> function suma($x,$y) { $x + $y }
PS> $resultado = suma 2 3
PS> $resultado
5
</syntaxhighlight>
 
Podemos crear unha librería de funcións e chamala dende outros scripts.
: Vexamos un exemplo:
:* Creamos o arquivo "C:\scripts\funciones.ps1" có seguinte contido.
<syntaxhighlight lang="powershell">
function sumar ($a, $b) {
    $a = [long]$a
    $b = [long]$b
    $resultado = $($a + $b)
    return $resultado
}
 
function multiplicar ($a, $b) {
    $a = [long]$a
    $b = [long]$b
    $resultado = $($a * $b)
    return $resultado
}
 
function restar ($a, $b) {
    $a = [long]$a
    $b = [long]$b
    $resultado = $($a - $b)
    return $resultado
}
</syntaxhighlight>
:* Creamos o arquivo "C:\scripts\proba.ps1" có seguinte contido.
<syntaxhighlight lang="powershell">
#Chamamos o arquivo de funcións
. "C:\scripts\funciones.ps1"
#Pedimos que o usuario interaccione
$numa = Read-Host "Introduce primer número"
$numb = Read-Host "Introduce segundo número"
#Mostramos os resultados
Write-Host "$numa + $numb = $(sumar $numa $numb)"
Write-Host "$numa * $numb = $(multiplicar $numa $numb)"
Write-Host "$numa - $numb = $(restar $numa $numb)"
</syntaxhighlight>
 
== Arquivos ==
Neste punto veremos algunhas operacións con arquivos que se poden realizar con PowerShell.
 
Os ''cmdlets'' máis importantes para o manexo de arquivos son os seguintes:
{| border="1" cellspacing="0" cellpadding="5"
! style="background:#ffdead;" | Cmdlet
! style="background:#ffdead;" | Descrición
! style="background:#ffdead;" | Alias
|-
| [http://technet.microsoft.com/en-us/library/hh849859.aspx Add-Content]
| Engade o contido a un arquivo.
| '''ac'''
|-
| '''Clear-Host'''
| Limpa a consola.
| '''cls, clear'''
|-
| [http://technet.microsoft.com/en-us/library/hh849854.aspx Clear-Item]
| Borra o contido do arquivo, pero non o arquivo.
| '''cli'''
|-
| [http://technet.microsoft.com/en-us/library/hh849793.aspx Copy-Item]
| Copia un arquivo ou un directorio.
| '''copy, cp, cpi'''
|-
| [http://technet.microsoft.com/en-us/library/hh849800.aspx Get-Childitem]
| Listar o contido de directorios.
| '''Dir, ls, gci'''
|-
| [http://technet.microsoft.com/en-us/library/hh849787.aspx Get-Content]
| Ler o contido de arquivos de texto.
| '''type, cat, gc'''
|-
| [http://technet.microsoft.com/en-us/library/hh849788.aspx Get-Item]
| Acceder a arquivos ou directorios.
| '''gi'''
|-
| [http://technet.microsoft.com/en-us/library/hh849851.aspx Get-ItemProperty]
| Ler as propiedades dun arquivo ou directorio.
| '''gp'''
|-
| [http://technet.microsoft.com/en-us/library/hh849794.aspx Invoke-Item]
| Abre un arquivo coa aplicación definida en Windows.
| '''ii'''
|-
| [http://technet.microsoft.com/en-us/library/hh849799.aspx Join-Path]
| Une dúas partes dunha ruta nunha única parte, por exemplo, un disco máis un nome de arquivo.
| -
|-
| [http://technet.microsoft.com/en-us/library/hh849795.aspx New-Item]
| Crea un novo arquivo ou directorio.
| '''ni'''
|-
| [http://technet.microsoft.com/en-us/library/hh849765.aspx Remove-Item]
| Borra moitos tipos de ''items'' como directorios, arquivos, variables, funcións, alias,...
| '''ri, rm, rmdir, del, erase, rd'''
|-
| [http://technet.microsoft.com/en-us/library/hh849763.aspx Rename-Item]
| Cambiarlle de nome a arquivos e directorios.
| '''ren, rni'''
|-
| [http://technet.microsoft.com/en-us/library/hh849858.aspx Resolve-Path]
| Resolve unha ruta incluídos os caracteres comodín.
| '''rvpa'''
|-
| [http://technet.microsoft.com/en-us/library/hh849844.aspx Set-ItemProperty]
| Establece a propiedade do arquivo ou directorio.
| '''sp'''
|-
| [http://technet.microsoft.com/en-us/library/hh849809.aspx Split-Path]
| Extraer unha parte específica dunha dirección.
| -
|-
| [http://technet.microsoft.com/en-us/library/hh849776.aspx Test-Path]
| Devolve ''True'' si existe unha dirección especificada.
| -
|-
 
|}
 
===Comprobación de arquivos===
Se queremos comprobar a existencia dun arquivo, por exemplo, na carpeta actual:
<syntaxhighlight lang="powershell">
PS> dir
    Directorio: C:\scripts
 
Mode                LastWriteTime    Length Name
----                -------------    ------ ----
-a---        02/01/2013    23:37        100 proba.ps1
 
PS> Test-Path .\proba.ps1
True
 
PS> Test-Path .\arquivo.txt
False
 
</syntaxhighlight>
 
===Lectura rápida de arquivos de texto===
O ''cmdlet'' '''get-content''' pode ler directamente o contido dun arquivo de texto especificado e pasa o seu contido a unha variable de tipo táboa. Cada liña lida do arquivo de texto será un elemento da táboa.
<syntaxhighlight lang="powershell">
PS> $contido = Get-Content ./texto.txt
PS> $contido
primeira
segunda
terceira
PS> $contido[0]
primeira
PS> $contido[1]
segunda
PS> $contido[2]
terceira
PS> $contido[-1]
terceira
PS> $contido.count
3
</syntaxhighlight>
 
===Escritura rápida de arquivos de texto===
Para escribir nun arquivo empregamos o ''cmdlet'' '''out-file'''.
 
Por exemplo, se queremos crear un arquivo de texto texto2.txt coa variable $contido antes empregada:
<syntaxhighlight lang="powershell">
PS> $contido | Out-File ./texto2.txt
PS> cat .\texto2.txt
primeira
segunda
terceira
</syntaxhighlight>
 
Se precisamos agregar unha cuarta liña no arquivo '''texto2.txt''', farémolo así:
<syntaxhighlight lang="powershell">
PS C:\scripts> "cuarta" | Out-File .\texto2.txt -append
PS C:\scripts> cat .\texto2.txt
primeira
segunda
terceira
cuarta
</syntaxhighlight>
 
Con '''Out-File''' podemos crear/agregar o que nos interese, e se implica varias liñas, tamén:
<syntaxhighlight lang="powershell">
PS> Get-Date | Format-List | Out-File .\texto2.txt -append
PS> cat .\texto2.txt
primeira
segunda
terceira
cuarta
 
DisplayHint : DateTime
Date        : 05/01/2013 0:00:00
Day        : 5
DayOfWeek  : Saturday
DayOfYear  : 5
Hour        : 23
Kind        : Local
Millisecond : 970
Minute      : 11
Month      : 1
Second      : 54
Ticks      : 634930243149708750
TimeOfDay  : 23:11:54.9708750
Year        : 2013
DateTime    : sábado, 05 de enero de 2013 23:11:54
 
</syntaxhighlight>
 
===Procura de cadeas en arquivos de texto===
Entre as [http://technet.microsoft.com/en-us/library/hh849958.aspx utilidades ''cmdlets''] exite unha denominada [http://technet.microsoft.com/en-us/library/hh849903.aspx Select-String] que nos permite buscar cadeas de texto dentro dunha variable ou un arquivo.
 
No seguinte exemplo buscamos a cadea te texto "segunda" no interior do arquivo "texto2.txt":
<syntaxhighlight lang="powershell">
PS> Select-String "segunda" .\texto2.txt
 
texto2.txt:2:segunda
 
</syntaxhighlight>
Como vemos, o resultado da procura indica o nome do arquivo, o número de liña onde atopou o que se buscaba, e a cadea que se estaba a buscar.
 
Tamén se pode buscar
 
<syntaxhighlight lang="powershell">
PS> Get-ChildItem -filter *.txt -recurse | Select-String "segunda"
 
texto.txt:2:segunda
texto2.txt:2:segunda
</syntaxhighlight>
 
== Expresións regulares ==
Como xa sabemos de Linux, as [[Exmpresions_Regulares_en_Linux|expresións regulares]] son o xeito máis potente e efectivo de atopar patróns de caracteres en cadeas de texto. PowerShell utiliza o operador [http://technet.microsoft.com/en-us/library/hh847759.aspx -match] para este propósito.
<syntaxhighlight lang="powershell">
PS > $cadea = "Ola caracola"
PS > $cadea
Ola caracola
PS > $cadea -match "cara"
True
PS > $cadea -match "peixe"
False
 
# Podemos empregar as expresións regulares para comprobar se o patrón existe ou non:
PS > $cadea -match "cara.o"
True
PS > $cadea -match "cara[a-z]+"
True
</syntaxhighlight>
 
* '''Distinguir entre maiúsculas e minúsculas:''' Hai que ter en conta que '''match''' non distingue entre maiúsculas e minúsculas nas súas procuras. Se precisamos facer esta distinción, empregaremos o operador '''cmatch'''.
<syntaxhighlight lang="powershell">
PS > $cadea -match "cara[A-Z]+"
True
PS > $cadea -cmatch "cara[A-Z]+"
False
</syntaxhighlight>
 
* '''Extraer patróns:''' Cando '''match''' ou '''-cmatch''' atopa un patrón nunha variable dada, PowerShell crea un hash novo chamado '''$matches''' para gardar o atopado:
<syntaxhighlight lang="powershell">
PS > $cadea -match "cara[A-Z]+"
True
PS > $matches
Name                          Value
----                          -----
0                              caracola
 
PS > $matches[0]
caracola
</syntaxhighlight>
 
* '''O problema das expresións regulares tendo máis dunha coincidencia: ''' Se empregando o operador '''-match''' con expresións regulares temos máis dunha coincidencia este operador NON traballará ben.
<syntaxhighlight lang="powershell">
PS > $ip = ipconfig
PS > $ip
 
Configuración IP de Windows
 
Adaptador de Ethernet Conexión de área local:
 
  Sufijo DNS específico para la conexión. . : Home
  Vínculo: dirección IPv6 local. . . : fe80::486a:b9c9:bee:fff0%11
  Dirección IPv4. . . . . . . . . . . . . . : 10.0.2.15
  Máscara de subred . . . . . . . . . . . . : 255.255.255.0
  Puerta de enlace predeterminada . . . . . : 10.0.2.2
 
Adaptador de túnel isatap.Home:
 
  Estado de los medios. . . . . . . . . . . : medios desconectados
  Sufijo DNS específico para la conexión. . : Home
 
Adaptador de túnel Teredo Tunneling Pseudo-Interface:
 
  Sufijo DNS específico para la conexión. . :
  Dirección IPv6 . . . . . . . . . . : 2001:0:5ef5:73b8:2c7a:4eb:f5ff:fdf0
  Vínculo: dirección IPv6 local. . . : fe80::2c7a:4eb:f5ff:fdf0%14
  Puerta de enlace predeterminada . . . . . : ::
PS > $ip -match '([0-9]{1,3}\.){3}[0-9]{1,3}'
  Dirección IPv4. . . . . . . . . . . . . . : 10.0.2.15
  Máscara de subred . . . . . . . . . . . . : 255.255.255.0
  Puerta de enlace predeterminada . . . . . : 10.0.2.2
PS > $matches
PS >
</syntaxhighlight>
: Para solucionar isto temos que empregar o obxecto [http://msdn.microsoft.com/en-us/library/system.text.regularexpressions.regex.aspx RegEx] do seguinte xeito:
<syntaxhighlight lang="powershell">
PS > $patronip = [regex] "([0-9]{1,3}\.){3}[0-9]{1,3}"
 
PS > $patronip.Matches($ip)
Groups  : {10.0.2.15, 2.}
Success  : True
Captures : {10.0.2.15}
Index    : 245
Length  : 9
Value    : 10.0.2.15
 
Groups  : {255.255.255.0, 255.}
Success  : True
Captures : {255.255.255.0}
Index    : 302
Length  : 13
Value    : 255.255.255.0
 
Groups  : {10.0.2.2, 2.}
Success  : True
Captures : {10.0.2.2}
Index    : 363
Length  : 8
Value    : 10.0.2.2
 
PS > $patronip.Matches($ip) | Select-Object -Property Value
Value
-----
10.0.2.15
255.255.255.0
10.0.2.2
 
PS > $patronip.Matches($ip) | ForEach-Object {"IP: $($_.Value)" }
IP: 10.0.2.15
IP: 255.255.255.0
IP: 10.0.2.2
 
PS >
</syntaxhighlight>
 
Con respecto á distinción entre maiúsculas e minúsculas dicir que, o obxecto '''RegEx''' as distingue por defecto, polo que, para solucionalo debemos poñer "(?i)" diante da expresión regular. Por exemplo un patrón para un mail sería:
<syntaxhighlight lang="powershell">
PS > $patronmail = [regex] "(?i)\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,4}\b"
PS >
</syntaxhighlight>
: Visitar este [http://technet.microsoft.com/en-us/library/ff730947.aspx enlace interesante].
 
* '''Substitucións: '''
O operador [http://blogs.technet.com/b/heyscriptingguy/archive/2011/03/21/use-powershell-to-replace-text-in-strings.aspx -replace] é o empregado en PowerShell para remprazar cadeas de texto.
<syntaxhighlight lang="powershell">
PS > "Ola Patricia" -replace "Ola", "Adeus"
Adeus Patricia
</syntaxhighlight>
Tamén podemos empregar expresións regulares e, neste caso, cada un dos resultados obtidos serán gardados por PowerShell en variables temporais chamadas $1, $2, $3...
<syntaxhighlight lang="powershell">
PS C:\Users\Administrador> "Ola Patricia" -match '(.*) (.*)'
True
PS C:\Users\Administrador> $matches
 
Name                          Value
----                          -----
2                              Patricia
1                              Ola
0                              Ola Patricia
 
PS > "Ola Patricia" -replace '(.*) (.*)', '$2 $1'
Patricia Ola
PS >
</syntaxhighlight>
 
== Administración do sistema ==
O punto forte de PowerShell é a administración do sistema operativo.
 
=== Obter información do sistema ===
Para obter información do sistema podemos empregar, entre outras as seguintes variables e cmdlets:
* '''$env:computername''' ---- Mostra o nome do equipo.
* '''$env:username''' ---- Mostra o nome do usuario logeado nese intre.
* '''$env:userdomain''' ---- Mostra o dominio no que se iniciou sesión.
* '''Get-Date''' ---- Mostra a data e hora actual do equipo.
* '''Get-HotFix''' ---- Mostra información sobre actualizacións e Service Packs do equipo.
* '''Get-WmiObject -Class Win32_ComputerSystem''' ---- Mostrar información do equipo.
::* [https://msdn.microsoft.com/en-us/library/aa394586(v=vs.85).aspx?cs-save-lang=1&cs-lang=windows%2bpowershell#code-snippet-1 Exemplos].
* '''Get-WmiObject -Class Win32_bios''' ---- Mostrar información da BIOS do equipo.
<syntaxhighlight lang="powershell">
#Buscar os equipos que teñen BIOS distinta ao equipo A05
$comp = get-content computers.txt
$comp | foreach {
$bios = get-wmiobject -class win32_bios -computername $_
$BiosVersion = $bios.SMBIOSBIOSVersion
if (!($BiosVersion –match “A05”)) {
add-content (“$_ $BiosVersion”) -path checkfailed.txt }
}
}
</syntaxhighlight>
* '''Get-WmiObject -Class Win32_PhysicalMemory''' ---- Mostrar información da Memoria instalada no equipo ou equipos.
* '''Get-WmiObject -Class Win32_Processor''' ---- Mostrar información do Procesador existente no equipo ou equipos.
* '''Get-WmiObject -Class Win32_DiskDrive''' ---- Mostrar información do Discos Duros existentes no equipo ou equipos.
:* '''Get-WmiObject -Class Win32_DiskPartition''' ---- Mostrar información das Particións existente no equipo ou equipos.
:* '''Get-WmiObject -Class Win32_logicaldisk''' ---- Mostrar información das Unidades lóxicas (C: D: E: ...) existente no equipo ou equipos.
* '''Get-WmiObject -Class Win32_OperatingSystem''' ---- Mostrar información do sistema operativo.
* '''Get-WmiObject -Class Win32_systemdriver''' ---- Mostrar información dos drivers instalados no sistema.
<syntaxhighlight lang="powershell">
#Se queremos ver só os drivers que se atopan "correndo"
PS> get-wmiobject -class win32_systemdriver -filter “state=‘Running’”
</syntaxhighlight>
* '''Get-WmiObject -Class Win32_UserAccount''' ---- Mostrar información das contas de usuario existentes no equipo ou no dominio ao que pertence o equipo.
* '''Get-WmiObject -Class Win32_Group''' ---- Mostrar información dos grupos existentes no equipo ou no dominio ao que pertence o equipo.
 
=== Os Proveedores ===
Os comandos de manipulación de arquivos nos permiten tamén xestionar:
* O rexistro.
* As variables.
* Alias.
* A base de datos de certificados X509.
* Funcións.
* O sistema de arquivos.
 
Así temos oito "proveedores" (''Provider'' ou ''PSProvider'') e, para conocelos, podemos teclear o comando '''''[http://technet.microsoft.com/en-us/library/ee176857.aspx Get-PsProvider]'''''.
<syntaxhighlight lang="powershell">
PS> Get-PSProvider
Name                Capabilities                                      Drives
----                ------------                                      ------
Alias                ShouldProcess                                    {Alias}
Environment          ShouldProcess                                    {Env}
FileSystem          Filter, ShouldProcess, Credentials                {C, D}
Function            ShouldProcess                                    {Function}
Registry            ShouldProcess, Transactions                      {HKLM, HKCU}
Variable            ShouldProcess                                    {Variable}
</syntaxhighlight>
 
Así, por exemplo, ver as variables de contorno:
<syntaxhighlight lang="powershell">
PS C:\Users\usuario> Get-ChildItem Env:
 
Name                          Value
----                          -----
ALLUSERSPROFILE                C:\ProgramData
APPDATA                        C:\Users\usuario\AppData\Roaming
CommonProgramFiles            C:\Program Files\Common Files
CommonProgramFiles(x86)        C:\Program Files (x86)\Common Files
CommonProgramW6432            C:\Program Files\Common Files
COMPUTERNAME                  PORTATIL
ComSpec                        C:\Windows\system32\cmd.exe
FP_NO_HOST_CHECK              NO
HOMEDRIVE                      C:
HOMEPATH                      \Users\usuario
LOCALAPPDATA                  C:\Users\usuario\AppData\Local
LOGONSERVER                    \\PORTATIL
MOZ_PLUGIN_PATH                C:\Program Files\Tracker Software\PDF Viewer\Win32\
NUMBER_OF_PROCESSORS          4
OS                            Windows_NT
Path                          C:\ProgramData\Oracle\Java\javapath;C:\Program Files (x86)\Intel\iCLS Client\;C:\Prog...
PATHEXT                        .COM;.EXE;.BAT;.CMD;.VBS;.VBE;.JS;.JSE;.WSF;.WSH;.MSC;.CPL
PROCESSOR_ARCHITECTURE        AMD64
PROCESSOR_IDENTIFIER          Intel64 Family 6 Model 69 Stepping 1, GenuineIntel
PROCESSOR_LEVEL                6
PROCESSOR_REVISION            4501
ProgramData                    C:\ProgramData
ProgramFiles                  C:\Program Files
ProgramFiles(x86)              C:\Program Files (x86)
ProgramW6432                  C:\Program Files
PSModulePath                  C:\Users\usuario\Documents\WindowsPowerShell\Modules;C:\Program Files\WindowsPowerShe...
PUBLIC                        C:\Users\Public
SESSIONNAME                    Console
SystemDrive                    C:
SystemRoot                    C:\Windows
TEMP                          C:\Users\usuario\AppData\Local\Temp
TMP                            C:\Users\usuario\AppData\Local\Temp
USERDOMAIN                    portatil
USERDOMAIN_ROAMINGPROFILE      portatil
USERNAME                      usuario
USERPROFILE                    C:\Users\usuario
VBOX_MSI_INSTALL_PATH          C:\Program Files\Oracle\VirtualBox\
windir                        C:\Windows
</syntaxhighlight>
 
Podemos tamén crear unha variable nova e logo eliminala:
<syntaxhighlight lang="powershell">
# Creamos a variable varTest có contido "Variable de Test"
PS C:\Users\usuario> Set-Location Env:
PS Env:\> New-Item -Path . -Name varTest -Value 'Variable de test'
 
Name                          Value
----                          -----
varTest                        Variable de test
 
# Buscamos todas as variables de Env que teñan no seu nome "Test"
PS Env:\> Get-ChildItem env: | where-Object {$_.Name -match "Test"} | fl
Name  : varTest
Value : Variable de test
 
# Comprobamos que existe a variable varTest
PS Env:\> Test-Path Env:varTest
True
 
# Recuperamos o seu contido (valor)
PS Env:\> $Env:varTest
Variable de test
 
# Eliminamos a variable varTest
PS Env:\> Remove-Item Env:\varTest
 
# Comprobamos que xa non existe
PS Env:\> Test-Path Env:varTest
False
</syntaxhighlight>
 
=== Apagar e reiniciar o equipo ===
Podemos empregar os seguintes cmdlets para apagar e reiniciar o equipo:
<syntaxhighlight lang="powershell">
# Apagar o equipo
PS> Stop-Computer
 
# Reiniciar o equipo
PS> Restart-Computer
</syntaxhighlight>
 
=== Instalar aplicacións e Actualizar o sistema ===
Para realizar estas tarefas empregaremos o [https://chocolatey.org/ Administrador de paquetes Chocolatey].
 
<source lang="powershell">
# Recuerda activar la ejecución de scripts ps1 en el equipo:
PS>Set-ExecutionPolicy RemoteSigned
# Instalamos Chocolatey:
PS>iex ((new-object net.webclient).DownloadString('https://chocolatey.org/install.ps1'))
# Podemos probar xa a instalar algún programa, como o Firefox:
PS>choco install firefox
# Para actualizalo:
PS>choco upgrade firefox
# Instalamos o módulo Windows Update PowerShell, que nos permitirá actualizar o Sistema:
PS>choco install pswindowsupdate
# Podemos ver a lista de actualizacións:
PS> Get-WUList -WindowsUpdate
# E tamén descargalas e actualizalas:
PS>Get-WUInstall -WindowsUpdate -AcceptAll -AutoReboot
</source>
: [https://blogs.technet.microsoft.com/heyscriptingguy/2014/08/23/weekend-scripter-powershell-and-chocolatey/ Enlace interesante].
 
'''Módulos Powershell para manexo de paquetes:'''
* [https://technet.microsoft.com/es-es/library/dn890951.aspx Technet Web]
<source lang="powershell">
# Instalar paquete
PS> Find-Package -Name virtualbox -Provider chocolatey | Install-Package
# Desinstalar paquete
PS>Uninstall-Package -name "openoffice"
</source>
 
'''Tamén podemos instalar aplicacións, actualizalas ou executar calquera comando REMOTAMENTE.''' Vexamos como facelo:
* [https://technet.microsoft.com/es-es/library/dd819505.aspx Executar comandos remotos en Windows]
: A execución remota de comandos emprega o protocolo [https://msdn.microsoft.com/en-us/library/windows/desktop/aa384470(v=vs.85).aspx WS-Management].
: Os requisitos dos equipos locales e remotos para executar comandos remotos podemos velos [https://technet.microsoft.com/es-es/library/dd315349.aspx aquí].
:: - Windows PowerShell 2.0 o posterior.
:: -  Microsoft .NET Framework 2.0 o posterior.
:: -  Versión 2.0 de Administración remota de Windows.
: Así, no equipo remoto:
:: - Activar o ''script'' remoto:
<source lang="powershell">
PS> Enable-PSRemoting
</source>
:: - Para ver si está activado:
<source lang="powershell">
PS> New-PSSession
Id Name            ComputerName    State        ConfigurationName    Availability
-- ----            ------------    -----        -----------------    ------------
  1 Session1        localhost      Opened        Microsoft.PowerShell    Available
</source>
:: - No equipo local, dende onde nos conectaremos, activar a execución de scripts:
<source lang="powershell">
PS> Set-ExecutionPolicy RemoteSigned
</source>
:: - E, xa por último, executar dende este equipo o script no equipo remoto empregando o comando Invoke-Command:
<source lang="powershell">
PS>  Invoke-Command -ComputerName wclient1.viso.local -filepath C:\scripts\instalacion.ps1
</source>
 
: Un exemplo de ''script'' pode ser o seguinte, que instala chocolatey e logo o Firefox, o Google Chrome e o VLC:
<source lang="powershell">
set-executionpolicy RemoteSigned -Confirm:$false
iex ((new-object net.webclient).DownloadString('https://chocolatey.org/install.ps1'))
choco install firefox -y
choco install googlechrome -y
choco install vlc -y
</source>
 
'''Configuración do mirror de paquetes de Chocolatey para evitar baneos en instalacións masivas nas aulas dos paquetes de Chocolatey:'''
 
'''Neste caso imos facer uso do servidor mirror.sanclemente.local do instituto. O comando a empregar é o seguinte:'''
 
<source lang="powershell">
choco source add -n=nexus -s=http://mirror.sanclemente.local:8081/repository/chocolatey-group/
</source>
 
'''A partir deste momento a descarga de paquetes farase empregando o mirror. Non será necesario polo tanto configurar o proxy para que Chocolatey se conecte a Internet.'''
 
'''Configuración dun proxy de rede para que Chocolatey se conecte a Internet:'''
 
: [https://github.com/chocolatey/choco/wiki/Proxy-Settings-for-Chocolatey Enlace]
 
<source lang="powershell">
# Por exemplo:
PS>choco config set proxy http://10.0.0.1:3128
</source>
 
=== Nome do equipo ===
Tarefas sinxelas como descubrir ou cambiar o nome do equipo fanse do seguinte xeito empregando o acceso a obxectos de '''WMI (Instrumental de Administración de Windows)'''.
* Para descubrir o nome dun equipo:
<syntaxhighlight lang="powershell">
# Descubrir o nombre dun equipo
## PowerShell 1.0 e 2.0
#PS > $equipo = Get-WmiObject win32_computersystem
## PowerShell 3.0 e posteriores
PS > $equipo = Get-CimInstance -ClassName Win32_ComputerSystem
PS > $equipo | fl
 
Domain              : iessantiago.local
Manufacturer        : innotek GmbH
Model              : VirtualBox
Name                : WSERVER1
PrimaryOwnerName    : Usuario de Windows
TotalPhysicalMemory : 1073270784
 
PS > $equipo.name
WSERVER1
</syntaxhighlight>
* Para cambiar o nome dun equipo no PowerShell 1.0 e 2.0:
<syntaxhighlight lang="powershell">
# Cambiar o nome dun equipo no PowerShell 1.0 e 2.0
# Creamos o obxecto $nombreequipo
PS > $equipo = Get-WmiObject win32_computersystem
 
# Vemos cal é o nome actual:
PS > $equipo.name
WIN-3E2I6RMDDEA
 
# Pedimos ao usuario o novo nome do equipo
# e o gardamos na variable $name:
PS > $name = Read-Host -Prompt "Introduce nome para o equipo"
Introduce nome para o equipo: Server00
PS > $name
Server00
 
# Configuramos o novo nome có método Rename do obxecto ComputerSystem:
PS > $equipo.Rename($name)
 
__GENUS          : 2
__CLASS          : __PARAMETERS
__SUPERCLASS    :
__DYNASTY        : __PARAMETERS
__RELPATH        :
__PROPERTY_COUNT : 1
__DERIVATION    : {}
__SERVER        :
__NAMESPACE      :
__PATH          :
ReturnValue      : 0
 
# Para que o cambio funcione hai que reiniciar o equipo:
PS > Restart-Computer
 
</syntaxhighlight>
 
* Para cambiar o nome dun equipo no PowerShell 3.0 e posterior:
<syntaxhighlight lang="powershell">
## PowerShell 3.0 e posteriores
PS > Rename-Computer -NewName WCLIENT1 -Restart -Force
 
</syntaxhighlight>
 
=== Configuración IP ===
* Para ver cal é a configuración de rede do teu equipo podemos facelo do seguinte xeito:
<syntaxhighlight lang="powershell">
# Crear o obxecto que representa a tarxeta de rede:
## PowerShell 1.0 e 2.0
#PS > $adaptador = Get-WmiObject Win32_NetworkAdapterConfiguration | Where-Object { $_.IpEnabled }
## PowerShell 3.0 e posteriores
PS > $adaptador = Get-CimInstance -ClassName Win32_NetworkAdapterConfiguration | Where-Object { $_.IpEnabled }
PS > $adaptador
 
DHCPEnabled      : False
IPAddress        : {192.168.1.100, fe80::84a9:ca57:4483:3184}
DefaultIPGateway : {192.168.1.1}
DNSDomain        :
ServiceName      : E1G60
Description      : Adaptador de escritorio Intel(R) PRO/1000 MT
Index            : 7
 
# Recorda:
# - Ver todas as propiedades do obxecto:
#### $adaptador | get-member -membertype property
# - Ver todos os métodos do obxecto:
#### $adaptador | get-member -membertype method
 
PS C:\> $adaptador.IPAddress
192.168.1.100
fe80::84a9:ca57:4483:3184
 
# Conseguir a IP:
PS C:\> $adaptador.IPAddress[0]
192.168.1.100
 
# Conseguir a MAC:
PS C:\> $adaptador.MACAddress
08:00:27:EC:98:04
</syntaxhighlight>
 
* Para cambiar a configuración IP do equipo facémolo do seguinte xeito...
:* PowerShell 1.0 e 2.0:
<syntaxhighlight lang="powershell">
# Parámetros a configurar:
$IP = "10.1.100.0"
$MS = "255.255.0.0"
$PE = "10.1.0.254"
$DNS1 = "10.4.0.1"
$DNS2 = "10.4.0.2"
 
# Crear o boxecto que representa a tarxeta de rede:
$adaptador = Get-WmiObject Win32_NetworkAdapterConfiguration | Where-Object { $_.IpEnabled }
# Cambiarlle a configuración IP ao equipo
# ---------------------------------------------------------- #
# Así configuramos unha IP estática:
$adaptador.EnableStatic($IP,$MS)
$adaptador.SetGateways($PE, [UInt16] 1)
$arrDNSServers = @($DNS1, $DNS2)
$adaptador.SetDNSServerSearchOrder($arrDNSServers)
# ----------------------------------------------------------- #
# Se queres configurar a IP por DHCP:
$adaptador.EnableDHCP()
$arrDNSServers = @()
$adaptador.SetDNSServerSearchOrder($arrDNSServers)
 
</syntaxhighlight>
 
:* PowerShell 3.0 e posteriores ([https://technet.microsoft.com/en-us/library/hh826123.aspx cmdlets para a administración da rede]):
<syntaxhighlight lang="powershell">
#Eliximos o adaptador que imos configurar
#Get-NetAdapter
#Unha vez que o temos claro...
$nic = "Ethernet"
$IP = "172.16.10.10"
$MS = 24
$PE = "172.16.10.1"
$DNS1 = "10.0.4.1"
$DNS2 = "10.0.4.2"
$arrDNSServers = @($DNS1, $DNS2) #Temos que facer un array cós servidores DNS
 
# Desabilitamos o DHCP se fose necesario
Set-NetIPInterface -InterfaceAlias $nic -DHCP Disabled
 
# Eliminamos a configuración IP do equipo se existe
Remove-NetIPAddress -InterfaceAlias $nic -IncludeAllCompartments -Confirm:$false  2> $null
# Eliminamos a configuración da Porta de Enlace se existe
Remove-NetRoute -InterfaceAlias $nic -Confirm:$false  2> $null
# Configuramos a IP estática, a máscara de subrede e a porta de enlace
New-NetIPAddress -InterfaceAlias $nic -AddressFamily IPv4 -IPAddress $IP -PrefixLength $MS -Type Unicast -DefaultGateway $PE
 
# Configuramos os servidores DNS
Set-DnsClientServerAddress -InterfaceAlias $nic -ServerAddresses $arrDNSServers
</syntaxhighlight>
 
=== Procesos e Servizos ===
* '''Procesos.''' A memoria de Windows, como calquera outro sistema operativo, serve para aloxar procesos que corren no sistema. Có ''cmdlet'' [http://technet.microsoft.com/en-us/library/hh849832.aspx Get-Process] de PowerShell podemos ver todos os procesos que actualmente están correndo no sistema:
<syntaxhighlight lang="powershell">
PS > Get-Process
 
Handles  NPM(K)    PM(K)      WS(K) VM(M)  CPU(s)    Id ProcessName
-------  ------    -----      ----- -----  ------    -- -----------
    43      5    1952      4980    53    0,22  1940 conhost
    277      10    1688      3724    42    0,38    320 csrss
    175      11    1876      5316    43    0,67    360 csrss
    66      7    1304      4188    49    0,02  1876 dwm
    489      33    13088      25544  159    0,41  1900 explorer
      0      0        0        24    0              0 Idle
    532      19    3448      9456    38    0,17    464 lsass
    143      7    2136      3800    18    0,03    472 lsm
    143      17    3216      7276    60    0,05  1584 msdtc
    554      23    48884      48340  563    1,05  1892 powershell
    184      12    3728      7584    30    0,47    456 services
    29      2      364      1032    5    0,09    244 smss
    261      18    6064      10260    73    0,08  1032 spoolsv
    154      8    5092      11520    36    2,23  1640 sppsvc
    287      32    6980      11192    46    0,17    12 svchost
    340      13    3220      8012    41    0,13    564 svchost
    68      6    1352      4300    29    0,03    632 svchost
    214      15    2672      6248    30    0,05    688 svchost
    289      15    7984      10800    43    0,20    776 svchost
    816      37    15428      27356  390    2,13    812 svchost
    284      22    5788      12040    59    0,17    856 svchost
    192      14    3280      9028    58    0,05    908 svchost
    398      26    10440      14328  335    0,20    948 svchost
    46      4      780      2620    13    0,00  1076 svchost
    461      0      112        300    3              4 System
    134      11    2700      5944    51    0,02  1492 taskhost
    110      9    1808      5008    35    0,02    624 VBoxService
    82      8    1392      4240    67    0,06  2000 VBoxTray
    77      9    1316      4176    43    0,13    368 wininit
    96      7    1496      4760    27    0,06    396 winlogon
 
PS >
</syntaxhighlight>
: Se queremos ver a información relevante do proceso '''powershell''', indicamos o seu nome:
<syntaxhighlight lang="powershell">
PS > Get-Process powershell
Handles  NPM(K)    PM(K)      WS(K) VM(M)  CPU(s)    Id ProcessName
-------  ------    -----      ----- -----  ------    -- -----------
    537      23    55300      55356  563    1,09  1892 powershell
 
PS >
</syntaxhighlight>
: Unha das propiedades que nos da ''Get-Process'' do proceso é '''WorkingSet''' que é o tamaño en bytes do proceso en cuestión:
<syntaxhighlight lang="powershell">
PS > (Get-Process powershell).ws
57688064
PS > (Get-Process powershell).ws /1mb
55,01953125
PS >
</syntaxhighlight>
: Outra propiedade interesante é a ruta onde está o arquivo do proceso en cuestión. Por exemplo, se tempos o Block de notas aberto e queremos ver onde está o seu arquivo en disco:
<syntaxhighlight lang="powershell">
PS > (Get-Process notepad).path
C:\Windows\system32\notepad.exe
PS >
</syntaxhighlight>
: Para mostrar varias propiedades dun proceso, empregamos o ''cmdlet'' [http://technet.microsoft.com/en-us/library/hh849892.aspx Format-Table] có seu argumento ''property'' e indicamos todas as propiedades que nos interesen separadas por comas:
<syntaxhighlight lang="powershell">
PS > Get-Process powershell | Format-Table name, company -auto
Name      Company
----      -------
powershell Microsoft Corporation
 
PS >
</syntaxhighlight>
: O argumento ''-auto'' axusta o ancho das columnas ao ancho dos datos visualizados. Se queremos visualizar moitas propiedades tamén podemos empregar [http://technet.microsoft.com/en-us/library/hh849957.aspx Format-List].
 
: Tamén podemos ver todos os procesos que teñan unha propiedade común. Por exemplo, se queremos ver todos os procesos pertencentes á compañía "Microsoft":
<syntaxhighlight lang="powershell">
PS > Get-Process | Where-Object {$_.company -like '*Microsoft*'}
 
Handles  NPM(K)    PM(K)      WS(K) VM(M)  CPU(s)    Id ProcessName
-------  ------    -----      ----- -----  ------    -- -----------
    43      5    1952      4980    53    0,27  1940 conhost
    263      10    1688      3724    42    0,38    320 csrss
    66      7    1304      4188    49    0,02  1876 dwm
    491      33    13184      25740  159    0,44  1900 explorer
    527      19    3448      9456    38    0,17    464 lsass
    140      7    2136      3800    18    0,03    472 lsm
    143      17    3216      7276    60    0,05  1584 msdtc
    72      7    1420      5016    71    0,03  1400 notepad
    528      23    49692      49872  563    1,22  1892 powershell
    180      12    3672      7564    29    0,47    456 services
    29      2      364      1032    5    0,09    244 smss
    261      18    6012      10244    73    0,08  1032 spoolsv
    152      8    5040      11488    35    2,28  1640 sppsvc
    291      32    6984      11196    46    0,17    12 svchost
    135      11    2700      5960    51    0,02  1492 taskhost
    77      9    1316      4176    43    0,13    368 wininit
    96      7    1496      4760    27    0,06    396 winlogon
 
PS >
</syntaxhighlight>
: Tamén podemos ver unha lista dos procesos agrupados e ordenados pola compañía á que pertencen:
<syntaxhighlight lang="powershell">
PS > Get-Process | Group-Object company | Sort-Object name | Format-List
 
Name  :
Count  : 2
Group  : {System.Diagnostics.Process (Idle), System.Diagnostics.Process (System)}
Values : {$null}
 
Name  : Microsoft Corporation
Count  : 27
Group  : {System.Diagnostics.Process (conhost), System.Diagnostics.Process (csrss), System.Diagnostics.Process (csrss),
          System.Diagnostics.Process (dwm)...}
Values : {Microsoft Corporation}
 
Name  : Oracle Corporation
Count  : 2
Group  : {System.Diagnostics.Process (VBoxService), System.Diagnostics.Process (VBoxTray)}
Values : {Oracle Corporation}
 
PS >
</syntaxhighlight>
: Por último, podemos finalizar un proceso de dous xeitos:
<syntaxhighlight lang="powershell">
#Modo 1:
PS > Get-Process notepad | Stop-Process
 
#Modo 2:
PS > (Get-Process notepad).kill()
 
PS >
 
</syntaxhighlight>
 
* '''Servizos.''' Un servizo é un proceso que se inicia no sistema antes de que o usuario inicie a súa sesión. Son típicos os servizos de Microsoft como a cola de impresión, o cliente DHCP, o cliente DNS, compartición de carpetas, audio, actualizacións de Windows, conexións de rede, etc. Outros fabricantes tamén aportan servizos ao sistema cando os seus produtos son instalados: antivirus, controladores, servidores, etc.
 
Podemos ver os servizos iniciados có ''cmdlet'' [http://technet.microsoft.com/en-us/library/hh849804.aspx Get-Service].
<syntaxhighlight lang="powershell">
PS > Get-Service
 
Status  Name              DisplayName
------  ----              -----------
Stopped  AeLookupSvc        Experiencia con aplicaciones
Stopped  ALG                Servicio de puerta de enlace de niv...
Stopped  AppIDSvc          Identidad de aplicación
Stopped  Appinfo            Información de la aplicación
Stopped  AppMgmt            Administración de aplicaciones
Stopped  AudioEndpointBu... Compilador de extremo de audio de W...
Stopped  AudioSrv          Audio de Windows
Running  BFE                Motor de filtrado de base
Running  BITS              Servicio de transferencia inteligen...
Stopped  Browser            Examinador de equipos
Stopped  CertPropSvc        Propagación de certificados
Stopped  clr_optimizatio... Microsoft .NET Framework NGEN v2.0....
Stopped  clr_optimizatio... Microsoft .NET Framework NGEN v2.0....
Stopped  COMSysApp          Aplicación del sistema COM+
Running  CryptSvc          Servicios de cifrado
Running  DcomLaunch        Iniciador de procesos de servidor DCOM
Stopped  defragsvc          Desfragmentador de disco
Running  Dhcp              Cliente DHCP
Stopped  Dnscache          Cliente DNS
Stopped  dot3svc            Configuración automática de redes c...
...
</syntaxhighlight>
: Este comando nos devolve o estado, o nome e a descrición de cada un dos servizos.
 
: Como vemos, o estado do servizo pode ser '''Running''' (en execución) ou '''Stopped''' (parado). Os servizos parados normalmente dependen de outros servizos para iniciarse. Para ver os servizos e as súas dependencias empregamos o argumento '''ServicesDependedOn'''.
<syntaxhighlight lang="powershell">
PS > Get-Service | Format-Table -property name, servicesdependedon -auto
 
Name                          ServicesDependedOn
----                          ------------------
AeLookupSvc                    {}
ALG                            {}
AppIDSvc                      {CryptSvc, RpcSs, AppID}
Appinfo                        {RpcSs, ProfSvc}
AppMgmt                        {}
AudioEndpointBuilder          {PlugPlay}
AudioSrv                      {AudioEndpointBuilder, RpcSs, MMCSS}
BFE                            {RpcSs}
BITS                          {EventSystem, RpcSs}
Browser                        {LanmanServer, LanmanWorkstation}
CertPropSvc                    {RpcSs}
clr_optimization_v2.0.50727_32 {}
clr_optimization_v2.0.50727_64 {}
COMSysApp                      {EventSystem, SENS, RpcSs}
CryptSvc                      {RpcSs}
DcomLaunch                    {}
defragsvc                      {RPCSS}
Dhcp                          {Afd, Tdx, NSI}
Dnscache                      {nsi, Tdx}
dot3svc                        {Ndisuio, RpcSs, Eaphost}
DPS                            {}
EapHost                        {RPCSS, KeyIso}
EFS                            {RPCSS}
eventlog                      {}
EventSystem                    {rpcss}
...
</syntaxhighlight>
: E para ver os servizos que dependen de cada un empregaríamos '''DependentServices''':
<syntaxhighlight lang="powershell">
PS > Get-Service | Format-Table -property name, dependentservices -auto
 
Name                          DependentServices
----                          -----------------
AeLookupSvc                    {}
ALG                            {}
AppIDSvc                      {}
Appinfo                        {}
AppMgmt                        {}
AudioEndpointBuilder          {AudioSrv}
AudioSrv                      {}
BFE                            {SharedAccess, RemoteAccess, PolicyAgent, MpsSvc...}
BITS                          {}
Browser                        {}
CertPropSvc                    {}
clr_optimization_v2.0.50727_32 {}
clr_optimization_v2.0.50727_64 {}
COMSysApp                      {}
CryptSvc                      {AppIDSvc}
DcomLaunch                    {wuauserv, WPDBusEnum, WinRM, SharedAccess...}
defragsvc                      {}
Dhcp                          {WinHttpAutoProxySvc}
Dnscache                      {}
dot3svc                        {}
DPS                            {}
EapHost                        {dot3svc}
EFS                            {}
...
</syntaxhighlight>
: Podemos parar un servizo en calquera momento con '''Stop-Service''':
<syntaxhighlight lang="powershell">
PS > Stop-Service spooler
</syntaxhighlight>
: E tamén inicialo con '''Start-Service''':
<syntaxhighlight lang="powershell">
PS > Start-Service spooler
</syntaxhighlight>
 
=== O sistema de arquivos ===
==== Discos Duros: Particionar, Instalar FS e Configurar Quotas ====
: Para administrar discos temos unha serie de [http://www.thomasmaurer.ch/2012/04/replace-diskpart-with-windows-powershell-basic-storage-cmdlets/ cmdlets interesantes], ainda que, a día de hoxe, case todas as accións as podemos seguir realizando có domando [http://technet.microsoft.com/es-es/library/cc766465(v=ws.10).aspx Diskpart].
:: Podemos ver un exemplo onde se vai a particionar un disco ('''disk 1''' neste caso)do seguinte xeito:
:: - 1 Partición Primaria de 10GB, formateada en NTFS, montada na letra P: e con etiqueta "DatosNTFS".
:: - 1 Partición Extendida que ocupe o resto do espazo libre do disco duro.
::: · 1 Partición Lóxica de 5GB, formateada en FAT32, montada na letra L: e con etiqueta "DatosFAT".
<syntaxhighlight lang="powershell">
# Creamos o contido do arquivo "discos.txt" onde estarán os comandos de diskpart.
# O contido deste arquivo será o seguinte:
SELECT DISK 1
CLEAN
CREATE PARTITION PRIMARY SIZE=10240
ASSIGN LETTER=P
FORMAT FS=NTFS LABEL="DatosNTFS" QUICK
CREATE PARTITION EXTENDED
CREATE PARTITION LOGICAL SIZE=5120
ASSIGN LETTER=L
FORMAT FS=FAT32 LABEL="DatosFAT" QUICK
####
#Dende a liña de comandos PowerShell chamamos ao comando diskpart:
PS>diskpart /s ./discos.txt
</syntaxhighlight>
: Vexamos algún comando interesante de Powershell:
* '''''get-psdrive''''' : Mostra os discos PowerShell que están dispoñibles.
<source lang="Powershell">
PS> Get-PSDrive | fl Name
Name : Alias
Name : C
Name : Cert
Name : D
Name : Env
Name : Function
Name : HKCU
Name : HKLM
Name : V
Name : Variable
Name : W
Name : WSMan
</source>
 
* '''''Initialize-Disk''''' :
* '''''Clear-Disk''''' :
* '''''New-Partition''''' :
* '''''format-volume''''' : Un cmdlet interesante que nos permite formatear un volume xa existente:
<source lang="Powershell">
PS> Format-Volume -DriveLetter W -FileSystem NTFS -Force -Confirm:$false
</source>
 
: Exemplo de particionamento dun disco crear nel dúas particións primarias (60% do tamaño e 40% do tamaño a outra).
:* A primeira en NTFS e a segunda en exFAT
:* Montadas en V: e W:
<syntaxhighlight lang="powershell">
$numero = 2 #Temos que saber o disco duro que imos particionar
$disco = Get-Disk -Number $numero
$tamdiscob = $disco.Size
$tampartV = [long]$tamdiscob * 60 / 100 # La partición V: será el 60% del disco
                                            # La W: el resto que quede
if ($disco.PartitionStyle -eq "RAW") {
    Initialize-Disk -Number $numero -PartitionStyle MBR
}
Clear-Disk -Number $numero -RemoveData -Confirm:$false
Initialize-Disk -Number $numero -PartitionStyle MBR
New-Partition -DiskNumber $numero -DriveLetter V -Size $tampartV
New-Partition -DiskNumber $numero -DriveLetter W -UseMaximumSize
 
Format-Volume -DriveLetter V -FileSystem NTFS -NewFileSystemLabel "Datos NTFS" -Force -Confirm:$false
Format-Volume -DriveLetter W -FileSystem exFAT -NewFileSystemLabel "Datos exFAT" -Force -Confirm:$false
</syntaxhighlight>
 
* '''Para configurar as Quotas de disco''' farémolo có comando [http://technet.microsoft.com/es-es/library/cc753059(v=ws.10).aspx Fsutil] que realiza tarefas relacionadas có sistema de arquivos NTFS.
: - Para obter unha lista das Quotas de disco existentes para un volumen ou partición:
<syntaxhighlight lang="powershell">
PS> Fsutil quota query D:
</syntaxhighlight>
: - Para configurar Quota no disco D: e facer que os membros do grupo G-Triton00, pertencente ao Dominio Triton00, teñan un nivel de advertencia de 25MB e un límite de 30MB:
<syntaxhighlight lang="powershell">
PS> Fsutil quota enforce D:
PS> Fsutil quota modify D: 26214400 31457280 Triton00\G-Triton00
</syntaxhighlight>
 
* Enlace interesante de [http://www.computerperformance.co.uk/powershell/powershell_wmi_disk.htm Administración de discos con Powershell].
* [http://technet.microsoft.com/en-us/library/hh848705.aspx Cmdlets para administrar o almacenamento en discos].
 
==== Arquivos e carpetas ====
Pódese dicir que, os arquivos son contenedores básicos de información e as carpetas son grupos de arquivos e carpetas.
 
* Para ver a ruta onde estamos actualmente na estrutura de carpetas empregamos a variable '''$pwd''' ou, simplemente '''pwd''':
<syntaxhighlight lang="powershell">
PS > $pwd
Path
----
C:\scripts
 
PS > $pwd | Get-Member
 
  TypeName: System.Management.Automation.PathInfo
 
Name        MemberType Definition
----        ---------- ----------
Equals      Method    bool Equals(System.Object obj)
GetHashCode  Method    int GetHashCode()
GetType      Method    type GetType()
ToString    Method    string ToString()
Drive        Property  System.Management.Automation.PSDriveInfo Drive {get;}
Path        Property  string Path {get;}
Provider    Property  System.Management.Automation.ProviderInfo Provider {get;}
ProviderPath Property  string ProviderPath {get;}
 
PS >
</syntaxhighlight>
: A ruta é a propiedade '''path''':
<syntaxhighlight lang="powershell">
PS > $pwd.path
C:\scripts
 
PS >
</syntaxhighlight>
: Conseguimos o mesmo resultado có ''cmdlet'' [http://technet.microsoft.com/en-us/library/hh849835.aspx Get-Location].
 
: Para cambiar a posición na árbore de ficheiros empregamos o ''cmdlet'' [http://technet.microsoft.com/en-us/library/hh849850.aspx Set-Location].
 
* Podemos obter un listado de todos os arquivos e carpetas dun directorio en particular empregando o ''cmdlet'' [http://technet.microsoft.com/en-us/library/hh849800.aspx Get-Childitem].
<syntaxhighlight lang="powershell">
PS > Get-Childitem -force
 
    Directorio: C:\
 
Mode                LastWriteTime    Length Name
----                -------------    ------ ----
d--hs        05/10/2011    15:06            $Recycle.Bin
d--hs        05/10/2011    15:05            Archivos de programa
d--hs        14/07/2009      7:06            Documents and Settings
d----        14/07/2009      5:20            PerfLogs
d-r--        05/10/2011    15:09            Program Files
d-r--        14/07/2009      7:06            Program Files (x86)
d--h-        05/10/2011    15:05            ProgramData
d--hs        05/10/2011    15:05            Recovery
d----        17/12/2012    20:08            scripts
d--hs        05/10/2011    14:58            System Volume Information
d-r--        05/10/2011    15:05            Users
d----        06/01/2013    12:20            Windows
-a-hs        06/01/2013    13:14 1073741824 pagefile.sys
 
PS >
</syntaxhighlight>
: O argumento '''-force''' visualiza todos os arquivos, incluidos os arquivos ocultos e de sistema. Como dato interesante, aparecen na columna da esquerda os 5 modos que poden ter cada arquivo mostrado. Estes modos son:
:: d (''directory''): carpeta
:: a (''archive''): arquivo
:: r (''read only''): só lectura
:: h (''hidden''): oculto
:: s (''system''): arquivo de sistema
: Para obter toda a estrutura de arquivos e carpetas dun directorio dado empregamos o argumento '''-recurse'''.
<syntaxhighlight lang="powershell">
PS > Get-ChildItem -force -recurse
 
    Directorio: C:\Users\Administrador\Documents
 
Mode                LastWriteTime    Length Name
----                -------------    ------ ----
d--hs        05/10/2011    15:05            Mi música
d--hs        05/10/2011    15:05            Mis imágenes
d--hs        05/10/2011    15:05            Mis vídeos
-a-hs        17/12/2012    19:23        402 desktop.ini
...
</syntaxhighlight>
: Tamén podemos empregar comodíns utilizando o argumento '''-filter'''.
<syntaxhighlight lang="powershell">
PS > Get-ChildItem -filter *.PDF -recurse
</syntaxhighlight>
 
* Podemos buscar cadeas de texto dentro de arquivos empregando o ''cmdlet'' [http://technet.microsoft.com/en-us/library/hh849903.aspx Select-String].
<syntaxhighlight lang="powershell">
PS C:\> Get-ChildItem -recurse | where { $_ | Select-String "ola" -quiet }
</syntaxhighlight>
 
* '''''New-Item''''' : Para crear arquivos e carpetas.
<source lang="powershell">
#Crear o directorio "Datos" en D:\
PS> new-item -type directory -path D:\Datos
#Para crear o directorio "Datos" en D:\ dos equipos EQ01, EQ02 e EQ03
PS> invoke-command -computername EQ01, EQ02, EQ03 -scriptblock { new-item -type directory -path D:\Datos }
</source>
 
* '''''Copy-Item''''' : Para copiar arquivos e carpetas.
<source lang="powershell">
#Copiar un arquivo:
PS> copy-item arquivo.txt arquivo-copia.txt
 
#Copiar un directorio:
PS> copy-item D:\Datos Z:\Datos-backup -recurse
 
#Copiar só os arquivos pdf:
PS> copy-item D:\Datos\*.pdf Z:\Datos-backup -recurse
</source>
: Sempre e cando se teñan os permisos axeitados, deberíase deser capaz de mover directorios e arquivos.
: Pero hai que ter en conta o seguinte: debido a que non puede utilizar '''''Move-Item''''' para mover recursos a través de volumes, a ruta de orixe e destino debe ter raíces idénticas. Se os arquivos dun directorio están en uso, un archivo está en uso ou se comparte un directorio, no se poderá mover o directorio ou o arquivo.
 
==== ACLs en volumes NTFS====
Nas unidades NTFS, os "permisos de acceso" determinan qué usuarios poden acceder aos arquivos e directorios. Para cada arquivo e directorio, os datos de seguridade forman o denominado '''"descritor de seguridade" (SD)'''. Os permisos de acceso reais están nas '''"listas de control de acceso (ACL)"'''. As ACLs divídense nun conxunto de '''"entradas de control de acceso (ACEs)"'''.
:: [http://informatica.iessanclemente.net/manuais/index.php/Introduci%C3%B3n_%C3%B3s_permisos_NTFS Introdución aos permisos NTFS].
Comentar por último, antes de comezar, que temos así dous tipos de permisos:
: - [http://technet.microsoft.com/en-us/library/ee649193(v=ws.10).aspx DACL]: Parte do descritor de seguridade dun obxecto que concede ou denega a usuarios e grupos específicos o permiso de acceso ao obxecto.
: - [http://technet.microsoft.com/es-es/library/cc731764(v=ws.10).aspx SACL]: Parte do descriptor de seguridade dun obxexto que especifica os eventos que se auditarán por usuario ou grupo. Algúns exemplos de eventos de auditoría son o acceso a arquivos, os intentos de inicio de sesión e os peches do sistema.
 
'''Para descubrir a configuración dos permisos NTFS empregaremos o ''cmdlet'' [http://technet.microsoft.com/en-us/library/hh849802.aspx Get-Acl].
<syntaxhighlight lang="powershell">
# Creamos a carpeta datos
PS > md datos
# Chequeamos a configuración de seguridade do directorio
PS > Get-Acl .\datos | fl
 
Path  : Microsoft.PowerShell.Core\FileSystem::C:\datos
Owner  : BUILTIN\Administradores
Group  : SERVIDOR\None
Access : NT AUTHORITY\SYSTEM Allow  FullControl
        BUILTIN\Administradores Allow  FullControl
        BUILTIN\Usuarios Allow  ReadAndExecute, Synchronize
        BUILTIN\Usuarios Allow  AppendData
        BUILTIN\Usuarios Allow  CreateFiles
        CREATOR OWNER Allow  268435456
Audit  :
Sddl  : O:BAG:S-1-5-21-763290472-4206933357-2196511326-513D:AI(A;OICIID;FA;;;SY)(A;OICIID;FA;;;BA)(A;OICIID;0x1200a9;;
        ;BU)(A;CIID;LC;;;BU)(A;CIID;DC;;;BU)(A;OICIIOID;GA;;;CO)
</syntaxhighlight>
 
Para ver os permisos de arquivos e sudirectorios do interior dun directorio de xeito recursivo, podemos empregar algo parecido a isto:
<syntaxhighlight lang="powershell">
PS C:\> Get-ChildItem c:\datos -recurse | get-acl | foreach { $_.path; $_.Access | ft -wrap }
Microsoft.PowerShell.Core\FileSystem::C:\datos\cosas
 
  FileSystemRights  AccessControlType IdentityReference          IsInherited    InheritanceFlags    PropagationFlags
  ----------------  ----------------- -----------------          -----------    ----------------    ----------------
        FullControl              Allow NT AUTHORITY\SYSTEM                True  ContainerInherit,                None
                                                                                      ObjectInherit
        FullControl              Allow BUILTIN\Administrad                True  ContainerInherit,                None
                                        ores                                          ObjectInherit
  ReadAndExecute,                Allow BUILTIN\Usuarios                  True  ContainerInherit,                None
        Synchronize                                                                  ObjectInherit
        AppendData              Allow BUILTIN\Usuarios                  True    ContainerInherit                None
        CreateFiles              Allow BUILTIN\Usuarios                  True    ContainerInherit                None
          268435456              Allow CREATOR OWNER                      True  ContainerInherit,          InheritOnly
                                                                                      ObjectInherit
 
 
Microsoft.PowerShell.Core\FileSystem::C:\datos\archivo.txt
 
  FileSystemRights  AccessControlType IdentityReference          IsInherited    InheritanceFlags    PropagationFlags
  ----------------  ----------------- -----------------          -----------    ----------------    ----------------
        FullControl              Allow NT AUTHORITY\SYSTEM                True                None                None
        FullControl              Allow BUILTIN\Administrad                True                None                None
                                        ores
  ReadAndExecute,                Allow BUILTIN\Usuarios                  True                None                None
        Synchronize
 
 
Microsoft.PowerShell.Core\FileSystem::C:\datos\cosas\archivo2.txt
 
  FileSystemRights  AccessControlType IdentityReference          IsInherited    InheritanceFlags    PropagationFlags
  ----------------  ----------------- -----------------          -----------    ----------------    ----------------
        FullControl              Allow NT AUTHORITY\SYSTEM                True                None                None
        FullControl              Allow BUILTIN\Administrad                True                None                None
                                        ores
  ReadAndExecute,                Allow BUILTIN\Usuarios                  True                None                None
        Synchronize
</syntaxhighlight>
 
O mellor nestes casos é gardar a saída do ''cmdlet'' '''Get-Acl''' nunha variable (que será en realidade un obxecto '''System.Security.AccessControl''' que representa as ACLs). Unha vez creado o obxecto podemos ler a propiedade ou manexar o método que nos interese:
<syntaxhighlight lang="powershell">
PS C:\> $permisos = Get-Acl C:\datos
PS C:\> $permisos.Access | ft -wrap
 
  FileSystemRights  AccessControlType IdentityReference          IsInherited    InheritanceFlags    PropagationFlags
  ----------------  ----------------- -----------------          -----------    ----------------    ----------------
        FullControl              Allow NT AUTHORITY\SYSTEM                True  ContainerInherit,                None
                                                                                      ObjectInherit
        FullControl              Allow BUILTIN\Administrad                True  ContainerInherit,                None
                                        ores                                          ObjectInherit
  ReadAndExecute,                Allow BUILTIN\Usuarios                  True  ContainerInherit,                None
        Synchronize                                                                  ObjectInherit
        AppendData              Allow BUILTIN\Usuarios                  True    ContainerInherit                None
        CreateFiles              Allow BUILTIN\Usuarios                  True    ContainerInherit                None
          268435456              Allow CREATOR OWNER                      True  ContainerInherit,          InheritOnly
                                                                                      ObjectInherit
</syntaxhighlight>
* Unha vez creado o obxecto, é moi interesante a opción que nos da o PowerShell de gardalo nun arquivo XML para o seu almacenamento. Logo poderemos empregar este arquivo XML para "clonar" as ACLs noutro directorio ou arquivo.
<syntaxhighlight lang="powershell">
PS> $acl = Get-Acl c:\datos
PS> $acl | Export-Clixml c:\permisos.xml
</syntaxhighlight>
 
'''Para configurar as ACLs dende un obxecto''' temos o ''cmdlet'' [http://technet.microsoft.com/en-us/library/hh849810.aspx Set-Acl]. Empregando o obxecto creado no exemplo anterior con '''Get-Acl''':
<syntaxhighlight lang="powershell">
# Primeiro creamos o obxecto:
PS> $acl = Get-Acl c:\datos
# Agora clonamos o obxecto ACL nos dun novo directorio:
PS> Set-Acl -Path C:\datos2 $acl
</syntaxhighlight>
Tamén podemos facelo, tal e como vimos antes, cun paso intermedio empregando un arquivo XML:
<syntaxhighlight lang="powershell">
# Gardamos o obxecto ACL directamente nun arquivo:
PS > Get-Acl c:\datos | Export-Clixml c:\permisos.xml
# Ese arquivo o podemos gardar, cambiar de equipo, etc
# Importamos o arquivo nun novo obxecto ACL:
PS > $acl = Import-Clixml C:\permisos.xml
# Aplicamos ese obxecto a un novo directorio ou arquivo:
PS > Set-Acl -Path C:\datos2 $acl
</syntaxhighlight>
 
'''Para configurar os permisos''' dende PowerShell temos os comandos '''CACLS''', '''XCACLS''' e, moito mellor, [http://technet.microsoft.com/es-es/library/cc753525(v=ws.10).aspx ICACLS]. Veremos, a continuación, o seu funcionamento:
* Para ver a axuda do comando:
<syntaxhighlight lang="powershell">
PS> icacls /?
ICACLS nombre /save archivoACL [/T] [/C] [/L] [/Q]
    almacena las DACL para los archivos y carpetas cuyos nombres coinciden
    en archivoACL para su uso posterior con /restore. Tenga en cuenta que no
    se guardan las SACL, el propietario ni las etiquetas de identidad.
 
ICACLS directorio [/substitute SidOld SidNew [...]] /restore archivoACL
                  [/C] [/L] [/Q]
    aplica las DACL almacenadas a los archivos del directorio.
...
</syntaxhighlight>
 
* [http://technet.microsoft.com/es-es/library/cc753525(v=ws.10).aspx ICACLS] permítenos almacenar nun arquivo as DACLs para os arquivos e carpetas que nos interesen empregando o parámetro '''/save''', logo poderemos recuperar os permisos empregando o parámetro '''/restore''':
<syntaxhighlight lang="powershell">
# ICACLS nome /save arquivoACL [/T] [/C] [/L] [/Q]
PS C:\> icacls C:\datos\* /save permisos.txt /T
archivo procesado: C:\datos\archivo.txt
archivo procesado: C:\datos\cosas
archivo procesado: C:\datos\cosas\archivo2.txt
Se procesaron correctamente 3 archivos; error al procesar 0 archivos
PS C:\> Get-Content permisos.txt
a r c h i v o . t x t
 
D : A I ( A ; I D ; F A ; ; ; S Y ) ( A ; I D ; F A ; ; ; B A ) ( A ; I D ; 0 x 1 2 0 0 a 9 ; ; ; B U )
 
c o s a s
 
D : A I ( A ; O I C I I D ; F A ; ; ; S Y ) ( A ; O I C I I D ; F A ; ; ; B A ) ( A ; O I C I I D ; 0 x 1 2 0 0 a 9 ;
; ; B U ) ( A ; C I I D ; L C ; ; ; B U ) ( A ; C I I D ; D C ; ; ; B U ) ( A ; O I C I I O I D ; G A ; ; ; C O )
 
c o s a s \ a r c h i v o 2 . t x t
 
D : A I ( A ; I D ; F A ; ; ; S Y ) ( A ; I D ; F A ; ; ; B A ) ( A ; I D ; 0 x 1 2 0 0 a 9 ; ; ; B U )
 
 
PS C:\>
</syntaxhighlight>
 
* Vexamos a recuperación dos permisos antes gardados no arquivo, empregamos para isto o comando '''/restore''':
<syntaxhighlight lang="powershell">
# ICACLS directorio [/substitute SidOld SidNew [...]] /restore archivoACL [/C] [/L] [/Q]
# Para restaurar todas as ACL gardadas no arquivo permisos.txt
# en todos os subdirectorios e arquivos que exista en C:\datos
PS C:\> icacls C:\datos\ /restore ./permisos.txt
archivo procesado: C:\datos\archivo.txt
archivo procesado: C:\datos\cosas
archivo procesado: C:\datos\cosas\archivo2.txt
Se procesaron correctamente 3 archivos; error al procesar 0 archivos
PS C:\>
 
# Fixádevos que agora non se pon o * despois de C:\datos\
</syntaxhighlight>
 
* Vamos a configurar a carpeta de exemplo ''C:\datos'' cunha serie de permisos:
: - Administrador: Control Total na carpeta, subcarpetas e arquivos.
: - Usuarios: Só Crear carpetas nesa carpeta.
: - Cando crea un usuario na carpeta o usuario terá control total sobre ela. Ningún outro usuario poderá entrar nesa carpeta.
<syntaxhighlight lang="powershell">
#Primeiro miramos os permisos iniciais:
PS C:\> get-acl c:\datos | foreach { $_.path; $_.Access | ft -wrap }
Microsoft.PowerShell.Core\FileSystem::C:\datos
 
  FileSystemRights  AccessControlType IdentityReference          IsInherited    InheritanceFlags    PropagationFlags
  ----------------  ----------------- -----------------          -----------    ----------------    ----------------
        FullControl              Allow NT AUTHORITY\SYSTEM                True  ContainerInherit,                None
                                                                                      ObjectInherit
        FullControl              Allow BUILTIN\Administrad                True  ContainerInherit,                None
                                        ores                                          ObjectInherit
  ReadAndExecute,                Allow BUILTIN\Usuarios                  True  ContainerInherit,                None
        Synchronize                                                                  ObjectInherit
        AppendData              Allow BUILTIN\Usuarios                  True    ContainerInherit                None
        CreateFiles              Allow BUILTIN\Usuarios                  True    ContainerInherit                None
          268435456              Allow CREATOR OWNER                      True  ContainerInherit,          InheritOnly
                                                                                      ObjectInherit
 
# Agora configuramos os permisos...
# Na seguinte liña rompemos a herdanza, borrando ademais todos os permisos anteriores,
# o Administrador terá permiso de control total,
# ese permiso se propagará logo a arquivos e carpetas existentes no interior dese directorio C:\datos
PS C:\> icacls C:\datos /inheritance:r /grant:r "Administrador:`(OI`)`(CI`)F"
archivo procesado: C:\datos
Se procesaron correctamente 1 archivos; error al procesar 0 archivos
# Hai que fixarse que no PowerShell, antes dos parénteses, hai que colocar a comiña esa... senón, non vai.
 
#Vexamos como van os pemisos ata o de agora:
PS C:\> Get-Acl C:\datos | ft -wrap
 
    Directorio: C:\
 
Path                                    Owner                                  Access
----                                    -----                                  ------
datos                                  BUILTIN\Administradores                SERVIDOR\Administrador Allow
                                                                                FullControl
 
# Agora engadimos o "Creator Owner" con Control Total.
PS C:\> icacls C:\datos /grant:r "CREATOR OWNER:`(OI`)`(CI`)F"
archivo procesado: C:\datos
Se procesaron correctamente 1 archivos; error al procesar 0 archivos
 
# Quédanos engadir o grupo usuarios con permisos de crear só carpetas nesta carpeta.
PS C:\> icacls c:\datos /grant:r "usuarios:`(NP`)`(AD,RD`)"
archivo procesado: c:\datos
Se procesaron correctamente 1 archivos; error al procesar 0 archivos
PS C:\> get-acl c:\datos | fl
 
Path  : Microsoft.PowerShell.Core\FileSystem::C:\datos
Owner  : BUILTIN\Administradores
Group  : SERVIDOR\None
Access : CREATOR OWNER Allow  FullControl
        BUILTIN\Administradores Allow  FullControl
        BUILTIN\Usuarios Allow  ReadData, AppendData
        SERVIDOR\Administrador Allow  FullControl
 
# Vemos que aparece, sen saber por que, un permiso ao grupo Administradores que non debería estar ahí,
# vamos a eliminalo:
PS C:\> icacls C:\datos /remove:g "Administradores"
archivo procesado: C:\datos
Se procesaron correctamente 1 archivos; error al procesar 0 archivos
PS C:\> get-acl c:\datos | fl
 
 
Path  : Microsoft.PowerShell.Core\FileSystem::C:\datos
Owner  : BUILTIN\Administradores
Group  : SERVIDOR\None
Access : CREATOR OWNER Allow  FullControl
        BUILTIN\Usuarios Allow  ReadData, AppendData
        SERVIDOR\Administrador Allow  FullControl
</syntaxhighlight>
 
=== Crear recursos compartidos e conectarse a eles ===
Para compartir carpetas na rede emprégase o comando [http://technet.microsoft.com/en-us/library/bb490712.aspx net share]. Con PowerShell 3.0 e posteriores podemos empregar tamén os cmdlets do módulo [https://technet.microsoft.com/en-us/library/jj635726(v=wps.630).aspx SMB Share] como veremos logo:
<syntaxhighlight lang="powershell">
PS> net share scripts=d:\scripts /grant:"Todos,FULL" /CACHE:None
# Para ver os recursos compartidos:
PS> net share
</syntaxhighlight>
 
Para conectarse a un recurso compartido dende outro equipo empregamos o comando [http://technet.microsoft.com/en-us/library/bb490717.aspx net use].
<syntaxhighlight lang="powershell">
PS> net use S: \\server\scripts /persistent:no
</syntaxhighlight>
 
* Para PowerShell 3.0 e posteriores empregaremos os ''cmdlets'' do módulo [https://technet.microsoft.com/en-us/library/jj635726(v=wps.630).aspx SMB Share] e podes obter moita axuda no seguinte [http://blogs.technet.com/b/josebda/archive/2012/06/27/the-basics-of-smb-powershell-a-feature-of-windows-server-2012-and-smb-3-0.aspx enlace]:
<syntaxhighlight lang="powershell">
# Ver a lista dos cmdlets do múdulo
PS> Get-Command -module smb*
CommandType    Name                                              ModuleName
-----------    ----                                              ----------
Alias          Move-SmbClient                                    SmbWitness
Function        Block-SmbShareAccess                              SmbShare
Function        Close-SmbOpenFile                                  SmbShare
Function        Close-SmbSession                                  SmbShare
Function        Disable-SmbDelegation                              SmbShare
Function        Enable-SmbDelegation                              SmbShare
Function        Get-SmbBandwidthLimit                              SmbShare
Function        Get-SmbClientConfiguration                        SmbShare
Function        Get-SmbClientNetworkInterface                      SmbShare
Function        Get-SmbConnection                                  SmbShare
Function        Get-SmbDelegation                                  SmbShare
Function        Get-SmbMapping                                    SmbShare
Function        Get-SmbMultichannelConnection                      SmbShare
Function        Get-SmbMultichannelConstraint                      SmbShare
Function        Get-SmbOpenFile                                    SmbShare
Function        Get-SmbServerConfiguration                        SmbShare
Function        Get-SmbServerNetworkInterface                      SmbShare
Function        Get-SmbSession                                    SmbShare
Function        Get-SmbShare                                      SmbShare
Function        Get-SmbShareAccess                                SmbShare
Function        Get-SmbWitnessClient                              SmbWitness
Function        Grant-SmbShareAccess                              SmbShare
Function        Move-SmbWitnessClient                              SmbWitness
Function        New-SmbMapping                                    SmbShare
Function        New-SmbMultichannelConstraint                      SmbShare
Function        New-SmbShare                                      SmbShare
Function        Remove-SmbBandwidthLimit                          SmbShare
Function        Remove-SmbMapping                                  SmbShare
Function        Remove-SmbMultichannelConstraint                  SmbShare
Function        Remove-SmbShare                                    SmbShare
Function        Revoke-SmbShareAccess                              SmbShare
Function        Set-SmbBandwidthLimit                              SmbShare
Function        Set-SmbClientConfiguration                        SmbShare
Function        Set-SmbPathAcl                                    SmbShare
Function        Set-SmbServerConfiguration                        SmbShare
Function        Set-SmbShare                                      SmbShare
Function        Unblock-SmbShareAccess                            SmbShare
Function        Update-SmbMultichannelConnection                  SmbShare
 
# Ver os recursos compartidos existentes no equipo:
PS> Get-SmbShare | fl
 
Name        : ADMIN$
ScopeName  : *
Path        : C:\Windows
Description : Admin remota
 
Name        : C$
ScopeName  : *
Path        : C:\
Description : Recurso predeterminado
 
Name        : IPC$
ScopeName  : *
Path        :
Description : IPC remota
 
# Creamos un novo directorio e logo o compartimos para Todos - Control Total:
PS> mkdir C:\COSA
PS>  New-SmbShare -Name COSA -Path C:\COSA -FullAccess Todos -Description "Cousas para compartir"
PS> Get-SmbShare | fl
...
Name        : COSA
ScopeName  : *
Path        : C:\COSA
Description : Cousas para compartir
...
 
# Para eliminar o recurso compartido:
PS> Remove-SmbShare -Name COSA -Force
</syntaxhighlight>
Para conectarse a un recurso compartido dende outro equipo, empregando PowerShell 3.0 ou posterior, empregamos os seguintes ''cmdlets'':
<syntaxhighlight lang="powershell">
# Para conectarse:
PS> New-SmbMapping -LocalPath S: -RemotePath \\W12Base\COSA$ -Persistent $False
Status                                  Local Path                              Remote Path
------                                  ----------                              -----------
OK                                      S:                                      \\W12Base\COSA$
 
# Para ver os recursos compartidos existentes:
PS> Get-SmbMapping
Status                                  Local Path                              Remote Path
------                                  ----------                              -----------
OK                                      S:                                      \\W12Base\COSA$
 
# Para eliminar un recurso compartido existente:
PS> Remove-SmbMapping -LocalPath S: -Force
 
</syntaxhighlight>
 
===Usuarios y Grupos del equipo local===
Resumen de los cmdlets existentes para administrar los Usuarios y Grupos del equipo local:
* Add-LocalGroupmember: agrega un miembro en un grupo local.
* Disable-LocalUser: desactivar cuenta de usuario.
* Enable-LocalUser: activar cuenta de usuario.
* Get-LocalGroup: mostrar conjunto de grupos de seguridad locales presentes en el puesto de trabajo.
* Get-LocalGroupMember: recuperar los miembros presentes en un grupo local.
* Get-LocalUser: mostrar el conjunto de cuentas de usuario locales presentes en el puesto de trabajo.
* New-LocalGroup: crear un nuevo grupo de seguridad.
* New-LocalUser: crear una nueva cuenta de usuario local.
* Remove-LocalGroup: elimina un grupo de seguridad local.
* Remove-LocalGroupMember: elimina un miembro de un grupo local
* Remove-LocalUser: elimina una cuenta de usuario local.
* Rename-LocalGroup: renombra un grupo de seguridad local.
* Rename-LocalUser: renombra una cuenta de usuario local.
* Set-LocalGroup: permite modificar las propiedades de un grupo de seguridad local.
* Set-LocalUser: permite modificar las propiedades de una cuenta de usuario local.
 
Y podemos ver un ejemplo donde se dan de alta los siguientes Usuarios y Grupos Locales:
[[imagen:ntfs01.JPG|center]]
<source lang="powershell">
#Tabla hash con lista de Grupos y Usuarios
$GruposUsuarios = @{"GrupoA"=@("Anxo","Andrea","AnaBelen"); "GrupoB"=@("Bruno","Breixo","AnaBelen")}
#Preparamos la contraseña ya cifrada
$password = "abc123.."
$pwd = ConvertTo-SecureString $password -AsPlainText -Force
 
#Iteramos en los grupos a dar de alta
foreach ($grupo in $GruposUsuarios.keys) {
    #Damos de alta el grupo
    New-LocalGroup -Name $grupo -Description "Miembros del $grupo"
 
    #Iteramos en los miembros de cada grupo
    foreach ($usuario in $GruposUsuarios[$grupo]) {
        #Hacemos un try - catch para no ver el error de dar altasde usuario repetidas
        try {
            #Agregamos el usuario al equipo
            New-LocalUser -Name $usuario -Password $pwd 2> $null
        }
        catch {
            "El usuario $usuario ya existe"
        }
        #Añadimos el usuario al grupo correspondiente
        Add-LocalGroupMember -Group $grupo -Member $usuario
    }
}
</source>
 
== A Seguridade ==
Está claro que hai que ter moito coidado cós scripts, pois a facilidade de facer cousas pode levarnos a unha situación peligrosa para o noso sistema.
=== A seguridade de PowerShell por defecto ===
PowerShell trae unhas normas de seguridade por defecto que son as seguintes:
* Os arquivos ps1 están asociados ao bloc de notas. Podemos asocialos ao PowerShell, pero hai que ter moito coidado, pois é moi sinxelo facer un doble clic e executar un script que, en realidade, queríamos editar.
* Unha política de execución limitada, tal e como vimos no primeiro punto desta axuda (Por defecto está en ''Restricted'' e o pasamos a ''RemoteSigned'').
 
== Active Directory ==
Os Servizos de Dominio de Active Directory (AD DS) proporcionan a funcionalidade dunha solución de Identidade e Acceso para redes de empresas. Esta infraestructura realizará o seguinte:
* Almacenar información sobre usuarios, grupos, ordenadores e outras identidades.
* Autenticar unha identidade.
* Control de acceso.
* Proporcionar un rastreo de auditoría.
 
O ''Active Directory'' emprega:
* [[Introdución_ao_LDAP._O_servidor_OpenLDAP|LDAP]] (Lightweight Directory Access Protocol).
* [[Introduci%C3%B3n_a_kerberos|Kerberos]]
* [[Conceptos_b%C3%A1sicos_de_DNS|DNS]]
 
É interesante comprender o significado dos termos '''DN (''Distinguished Name'')''', '''RDN (''Relative Distinguished Name'')''' y '''CN (''Common Name'')''':
* Os '''DN''' son un tipo de ruta cara un obxecto en ''Active Directory''. Cada obxecto en AD ten un único DN. Un usuario chamado Brais Piñeiro, que está no interior da OU Direccion, que, á súa vez, está no interior da OU Triton00 e pertence ao dominio Triton00.local, ten o DN:
:: CN=Brais Piñeiro,OU=Direccion,OU=Triton00,DC=Triton00,DC=local.
: - O DN é un camiño a partires do obxecto ata o máis alto nivel do dominio no nome de espazo DNS triton00.local.
: - O CN trátase do nome común do usuario, é dicir, o seu nome completo.
: - OU é a Unidade Organizativa.
: - E, por último, DC significa Compoñente de Dominio.
* O fragmento do DN anterior ao primeiro OU ou contedor chámase '''"Nome distintivo Relativo" (RDN)'''. No caso de Brais, o RDN do obxecto é CN=Brais.
: - Como o DN dun obxecto debe ser único dentro do servizo de directorio, o RDN dun obxecto debe ser único dentro do seu contedor.
 
=== Instalación dos Servizos de Dominio de Active Directory ===
* Para instalar estes servizos, é dicir, promocionar o equipo Windows 2008 a Servidor de Dominio empregaremos a aplicación [http://technet.microsoft.com/es-es/library/cc732887(v=ws.10).aspx dcpromo.exe].
 
* No Windows 2012 a aplicación ''dcpromo'' non existe, o xeito de promocionar o equipo a Servidor de Dominio será o seguinte:
<source lang="powershell">
# Instalar os servizos de Active Directory no servidor:
PS > Install-WindowsFeature –Name AD-Domain-Services –ComputerName NomedoEquipo
# Promocionar o servidor:
PS > Invoke-Command –ComputerName NomedoEquipo
–ScriptBlock {Import-Module ADDSDeployment;Install-ADDSForest
–CreateDNSDelegation:$False –DatabasePath “C:\Windows\NTDS” –DomainMode “Win2012″
–DomainName “triton.ga” –DomainNetbiosName “TRITON” –ForestMode “Win2012″
–InstallDNS:$True –LogPath “C:\Windows\NTDS” –NoRebootOnCompletion:$False
–SysVolPath “C:\Windows\SysVol” –force:$true }
</source>
 
=== Elevar o Nivel Funcional do Bosque ===
 
[https://technet.microsoft.com/es-es/library/understanding-active-directory-functional-levels(v=ws.10).aspx Os Niveis funcionais] determinan as '''capacidades''' de dominio o bosque de Servicios de dominio de Active Directory (AD DS) que están dispoñibles. Tamén determinan os sistemas operativos Windows Server que se poden executar nos controladores de dominio do dominio ou do bosque.
: Por outro lado, os niveis funcionais NON afectan aos sistemas operativos que se poden executar nas estacións de traballo e nos servidores membros que están unidos ao dominio ou ao bosque.
: Cando implementamos AD DS, mellor establecer os niveis funcionais de dominio e de bosque no valor máis alto que admita a nosa contorna. Deste xeito, poderase empregar o maior número posible de características de AD DS.
: Por exemplo, e estamos seguros de que nunca se agregará ao dominio ou ao bosque controladores de dominio que executen Windows Server 2008, mellor seleccionar o nivel funcional de Windows Server 2012 (ou, do mesmo xeito Windows 2012 R2) durante o proceso de implementación. Polo contrario, se existe posibilidade de que se vaia conservar ou agregar algún controlador de dominio que execute Windows Server 2008, hai que seleccionar o nivel funcional de Windows Server 2008.
 
 
Para coñecer o Nivel Funcional no que se atopa o Bosque podemos empregar o comando [http://technet.microsoft.com/en-us/library/hh852189.aspx Get-ADForest].
<source lang="powershell">
PS > $forest = Get-ADForest
PS > $forest.ForestMode
Windows2012R2Forest
</source>
 
Para elevar o Nivel Funcional do Bosque empregaremos o comando [http://technet.microsoft.com/en-us/library/hh852243.aspx Set-ADForestMode]. Vexamos un exemplo:
<source lang="powershell">
PS > Set-ADForestMode -Identity animamundi.ga -ForestMode Windows2012R2Forest
PS > Get-ADForest
ApplicationPartitions : {DC=ForestDnsZones,DC=animamundi,DC=ga, DC=DomainDnsZones,DC=triton,DC=ga}
CrossForestReferences : {}
DomainNamingMaster    : server01.triton.ga
Domains              : {triton.ga}
ForestMode            : Windows2012R2Forest
GlobalCatalogs        : {server01.triton.ga}
Name                  : triton.ga
PartitionsContainer  : CN=Partitions,CN=Configuration,DC=animamundi,DC=ga
RootDomain            : triton.ga
SchemaMaster          : server01.triton.ga
Sites                : {Default-First-Site-Name}
SPNSuffixes          : {}
UPNSuffixes          : {}
</source>
 
=== Elevar o Nivel Funcional do Dominio ===
Faise do mesmo xeito que có Bosque:
<source lang="powershell">
PS > Set-ADDomainMode -Identity triton.ga -DomainMode Windows2012R2Domain
 
Confirmar
¿Está seguro de que desea realizar esta acción?
Se está realizando la operación "Set" en el destino "DC=triton,DC=ga".
[S] Sí  [O] Sí a todo  [N] No  [T] No a todo  [U] Suspender  [?] Ayuda (el valor predeterminado es "S"): S
 
PS > Get-ADDomain
AllowedDNSSuffixes                : {}
ChildDomains                      : {}
ComputersContainer                : CN=Computers,DC=triton,DC=ga
DeletedObjectsContainer            : CN=Deleted Objects,DC=triton,DC=ga
DistinguishedName                  : DC=triton,DC=ga
DNSRoot                            : triton.ga
DomainControllersContainer        : OU=Domain Controllers,DC=triton,DC=ga
DomainMode                        : Windows2012R2Domain
DomainSID                          : S-1-5-21-3472920172-2353984534-3407129034
ForeignSecurityPrincipalsContainer : CN=ForeignSecurityPrincipals,DC=triton,DC=ga
Forest                            : triton.ga
InfrastructureMaster              : wserver1.triton.ga
LastLogonReplicationInterval      :
LinkedGroupPolicyObjects          : {CN={31B2F340-016D-11D2-945F-00C04FB984F9},CN=Policies,CN=System,DC=triton,DC=
                                    ga}
LostAndFoundContainer              : CN=LostAndFound,DC=triton,DC=ga
ManagedBy                          :
Name                              : triton
NetBIOSName                        : triton
ObjectClass                        : domainDNS
ObjectGUID                        : 9026b492-72cb-4d8e-a3ff-b62f5c08c48d
ParentDomain                      :
PDCEmulator                        : wserver1.triton.ga
QuotasContainer                    : CN=NTDS Quotas,DC=triton,DC=ga
ReadOnlyReplicaDirectoryServers    : {}
ReplicaDirectoryServers            : {wserver1.triton.ga}
RIDMaster                          : wserver1.triton.ga
SubordinateReferences              : {DC=ForestDnsZones,DC=triton,DC=ga, DC=DomainDnsZones,DC=animamundi,DC=ga,
                                    CN=Configuration,DC=triton,DC=ga}
SystemsContainer                  : CN=System,DC=triton,DC=ga
UsersContainer                    : CN=Users,DC=triton,DC=ga
</source>
 
=== Integrar a zona DNS no Active Directory ===
: Para realizar a integración da zona DNS no Active Directory seguir o seguinte [http://technet.microsoft.com/es-es/library/cc463537%28v=ws.10%29.aspx enlace].
: Para confirmar que un controlador de dominio foi rexistrado no DNS, hai que abrir a liña de comandos e executar:
<source lang="powershell">
PS> dcdiag /test:registerindns /dnsdomain:<domain name> /v
</source>
 
=== Automatizar a creación e configuración de obxectos do dominio ===
''Active Directory'' ten alguhas ferramentas de liña de comandos '''DS'''. Os seguintes comandos '''DS''' son soportados en Windows Server 2008:
* [http://technet.microsoft.com/es-es/library/cc753708(v=ws.10).aspx Dsadd] : Crea un obxecto no directorio activo.
* [http://technet.microsoft.com/es-es/library/cc755162(v=ws.10).aspx Dsget] : Devolve atributos específicos dun obxecto.
* [http://technet.microsoft.com/en-us/library/cc732406(v=ws.10).aspx Dsmod] : Modifica atributos específicos dun obxecto.
* [http://technet.microsoft.com/en-us/library/cc731094(v=ws.10).aspx Dsmove] : Move un obxecto a un novo contedor ou Unidade Organizativa.
* [http://technet.microsoft.com/en-us/library/cc731865(v=ws.10).aspx Dsrm] : Elimina un obxecto, todos os obxectos na subárbore baixo un obxecto contedor, ou ambos.
* [http://technet.microsoft.com/es-es/library/cc732952(v=ws.10).aspx Dsquery] : Realiza unha consulta baseada nos parámetros proporcionados na liña de comandos e devolve unha lista cós obxectos que coinciden.
 
==== Crear Unidades Organizativas ====
* Para crear unidades organizativas empregamos o comando [http://technet.microsoft.com/es-es/library/cc770883(v=ws.10).aspx Dsadd OU].
<syntaxhighlight lang="powershell">
PS C:\> dsadd ou "ou=PROGRAMACION, ou=TRITON00, dc=TRITON00, dc=LOCAL"
</syntaxhighlight>
 
* O comando de Powershell comando para crealas:
<syntaxhighlight lang="powershell">
PS C:\> New-ADOrganizationalUnit -DisplayName "Programacion" -Name "Programacion" -path "ou=TRITON00, dc=TRITON00, dc=LOCAL"
</syntaxhighlight>
 
 
* Tamén podemos crear Unidades Organizativas empregando PowerShell.
<syntaxhighlight lang="powershell">
# Conectámonos ao contedor da OU a crear
$objADSI = [ADSI]“LDAP://OU=TRITON00,DC=TRITON00,DC=LOCAL”
 
# Invocamos ao método Create do contedor indicando:
# - O tipo de obxecto a crear: "organizationalUnit"
# - O nome distintivo relativo, RDN: "PROGRAMACION"
$objOU = $objADSI.create("organizationalUnit", "OU=PROGRAMACION")
 
# Executamos os cambios en AD có método SetInfo do obxecto
$objOU.setInfo()
</syntaxhighlight>
 
==== Crear usuarios ====
Vexamos distintas ferramentas para agregar usuarios:
* '''Crear usuarios con [http://technet.microsoft.com/es-es/library/cc753708(v=ws.10).aspx Dsadd].'''
O comando [http://technet.microsoft.com/es-es/library/cc731279(v=ws.10).aspx Dsadd user] crea un obxecto de usuario e acepta parámetros que especifican as propiedades do usuario.
<syntaxhighlight lang="powershell">
PS C:\> dsadd user "cn=Brais Piñeiro, ou=direccion, ou=triton00, dc=triton00, dc=local"
-samid brais -upn brais@triton00.local -fn Brais -mi BP -ln Piñeiro -display Brais -desc "Membro da Dirección"
-email brais@triton00.local -pwd abc123.. -mustchpwd yes
-hmdrv U: -hmdir \\servidor\usuarios$\brais -profile \\servidor\perfiles$\brais -loscr direccion.bat -disabled no
dsadd correcto:cn=Brais Piñeiro,ou=direccion,ou=triton00,dc=triton00,dc=local
PS C:\>
</syntaxhighlight>
: - O comando Dsadd crea o usuario na OU correspondente.
: - Tamén lle configura os parámetros: Nome, Apelidos, Siglas, Descrición, email,...
: - Configura o directorio persoal do usuario, pero ¡Ollo! '''a utilidade non crea o directorio, ten ese erro!!!'''. Para resolver este problema faremos do seguinte xeito:
<syntaxhighlight lang="powershell">
# Créase a carpeta persoal do usuario
# PS> mkdir V:\usuarios\brais
PS> New-Item -ItemType directory -Path V:\usuarios\brais
# Rómpese a herdanza copiando os permisos existentes
# e logo dámoslle ao usuario Control Total sobre a súa carpeta
PS> icacls V:\usuarios\brais /inheritance:d /grant:r "brais:`(OI`)`(CI`)F"
</syntaxhighlight>
: - Configura o directorio do perfil móbil para o usuario.
: - Configura un contrasinal base para o usuario e fai que o teña que cambiar no primeiro inicio de sesión.
 
* '''Crear usuarios con PowerShell.'''
Para crear usuarios empregando PowerShell podemos facelo de dous xeitos:
: - O primeiro é empregar o cmdlet [https://technet.microsoft.com/en-us/library/ee617253.aspx New-ADUser]:
<source lang="powershell">
#Creamos un password cifrado
$password = ConvertTo-SecureString "abc123.." -AsPlainText -Force
 
#Crear el nuevo usuario
New-ADUser -Name "Profesor00" -SamAccountName "Profesor00" `
-GivenName "Profesor" -SurName "Torres" `
–path ‘OU=profesores,OU=usuarios,OU=IES00,dc=IES00,dc=local’ `
-Enabled $true -AccountPassword ${password} -ChangePasswordAtLogon $false `
-HomeDrive 'P:' -HomeDirectory '\\WSERVER1\Usuarios00$\Profesores00\profesor00' `
-ProfilePath '\\WSERVER1\Perfiles00$\profesor00' `
-ScriptPath 'inicio.bat'
 
##Crear directorio personal del usuario
#New-Item -Path 'V:\Usuarios00\Profesores00\' -Name 'Profesor00' -ItemType 'directory'
New-Item -Path '\\WSERVER1\Usuarios00$\Profesores00\' -Name 'Profesor00' -ItemType 'directory'
 
###Configurar permisos NTFS del directorio personal del usuario
####Administradores - CT
####Usuario dueño de ese directorio - CT
icacls '\\WSERVER1\Usuarios00$\Profesores00\Profesor00' /inheritance:r /grant:r 'Administradores:(OI)(CI)F'
icacls '\\WSERVER1\Usuarios00$\Profesores00\Profesor00' /grant:r 'Profesor00:(OI)(CI)F'
 
#Agregar el usuario a sus grupos
Add-ADGroupMember -Identity 'CN=G-Profesores,OU=profesores,OU=usuarios,OU=IES00,dc=IES00,dc=local' `
-Members 'CN=profesor00,OU=profesores,OU=usuarios,OU=IES00,dc=IES00,dc=local'  </source>
 
: - O segundo xeito é o seguinte:
<syntaxhighlight lang="powershell">
# Conectámonos ao contedor do usuario a crear
PS > $objOU=[ADSI]"LDAP://OU=direccion,ou=triton00,dc=triton00,dc=local"
# Invocamos ao método Create do contedor indicando:
# - O tipo de obxecto a crear: "user"
# - O nome distintivo relativo, RDN: "Andrea Torres"
PS > $objUser=$objOU.Create("user","CN=Andrea Torres")
# Configuramos ás propiedades que nos interesen do novo usuario
# para esta tarefa empregamos o método Put.
# - A única obrigatorio sAMAccountName :
PS > $objUser.Put("sAMAccountName","andreat")
# Executamos os cambios en AD có método SetInfo do obxecto
PS > $objUser.SetInfo()
 
</syntaxhighlight>
 
Outras propiedades a configurar empregando o método '''Put''':
: -[http://www.selfadsi.org/user-attributes.htm Páxina onde se explican todas as propiedades dos Usuarios].
: -É interesante empregar a ferramenta [http://technet.microsoft.com/es-es/library/cc771975.aspx Editor ADSI] (''Active Directory Service Interfaces'') para ver as propiedades configuradas de cada un dos obxectos do AD.
 
{| border="0" cellspacing="0" cellpadding="5" width="90%"
| * '''Ficha "General":'''
<syntaxhighlight lang="powershell">
$objUser.Put("distinguishedName","CN=Brais Piñeiro,OU=Direccion,OU=Triton00,DC=Triton00,DC=Local")
$objUser.Put("cn","Brais Piñeiro")
$objUser.Put("name","Brais Piñeiro")
# Nombre de pila:
$objUser.Put("givenName","Brais")
# Iniciales:
$objUser.Put("initials","BP")
# Apellidos:
$objUser.Put("sn","Piñeiro")
# Nombre para mostrar:
$objUser.Put("displayName","Brais")
# Descripción:
$objUser.Put("description","Membro da Dirección")
# Número de Teléfono:
$objUser.Put("telephoneNumber","981 981 981")
# Correo electrónico:
$objUser.Put("mail","brais.pineiro@triton00.local")
# Página web:
$objUser.Put("wWWHomePage","www.triton00.local/brais")
</syntaxhighlight>
| [[Imagen:W2008_1.png|center|thumb|200px]]
|-
| * '''Ficha "Dirección":'''
<syntaxhighlight lang="powershell">
# Calle:
$objUser.Put("streetAddress","Hórreo 50, 1º Esquerda")
# Ciudad:
$objUser.Put("l","Santiago de Compostela")
# Estado o provincia:
$objUser.Put("st","A Coruña")
# Código postal:
$objUser.Put("postalCode","15.702")
# Páis o región:
$objUser.Put("co","España")
$objUser.Put("c","ES")
$objUser.Put("countryCode","724")
</syntaxhighlight>
: - [http://technet.microsoft.com/en-us/library/ee799297(v=cs.20).aspx Táboa de códigos de países].
| [[Imagen:W2008_2.png|center|thumb|200px]]
|-
| * '''Ficha "Cuenta":'''
<syntaxhighlight lang="powershell">
# Nombre de inicio de sesión de usuario.
$objUser.Put("userPrincipalName","brais@triton00.local")
# Nombre de inicio de sesión de usuario (anterior a Windows 2000).
$objUser.Put("sAMAccountName","brais")
 
</syntaxhighlight>
| [[Imagen:W2008_3.png|center|thumb|200px]]
|-
| * '''Ficha "Perfil":'''
<syntaxhighlight lang="powershell">
# Perfil de usuario.
# Ruta de acceso al perfil:
$objUser.Put("profilePath","\\servidor\perfiles$\brais")
# Script de inicio de sesión:
$objUser.Put("scriptPath","direccion.ps1")
# Carpeta particular.
# Conectar:
$objUser.Put("homeDrive","U:")
$objUser.Put("homeDirectory","\\servidor\usuarios$\brais")
</syntaxhighlight>
| [[Imagen:W2008_4.png|center|thumb|200px]]
|-
| * '''Ficha "Teléfonos":'''
<syntaxhighlight lang="powershell">
# Números de teléfono.
# Domicilio:
$objUser.Put("homePhone","986234567")
# Móvil:
$objUser.Put("mobile","685 685 685")
</syntaxhighlight>
| [[Imagen:W2008_5.png|center|thumb|200px]]
|-
| * '''Ficha "Organización":'''
<syntaxhighlight lang="powershell">
# Puesto:
$objUser.Put("title","Director Xeral")
# Departamento:
$objUser.Put("departament","Dirección")
# Organización:
$objUser.Put("company","Triton00")
</syntaxhighlight>
| [[Imagen:W2008_6.png|center|thumb|200px]]
|-
|}
 
===== Administrar contas de usuario =====
O propósito principal dos obxectos de usuario en AD é dar soporte á autenticación dunha persoa ou dun servizo. As contas se crean, se administran e, as veces, se eliminan. Vexamos as tarefas administrativas máis comúns relacionadas coas contas de usuario:
* '''Restabrecer o contrasinal de usuario:'''
: Se o usuario esquece o seu contrasinal debemos cambiarlla por outra e logo configurar a conta para que o usuario teña que cambiar este novo contrasinal, pois o administrador non debería de sabela.
: - Para facer operación empregaremos o comando [http://technet.microsoft.com/en-us/library/cc732406(v=ws.10).aspx Dsmod]:
<syntaxhighlight lang="powershell">
PS C:\> dsmod user "cn=Andrea,ou=direccion,ou=triton00,dc=triton00,dc=local" -pwd abc123.. -mustchpwd yes
dsmod correcto:cn=Andrea,ou=direccion,ou=triton00,dc=triton00,dc=local
PS C:\>
</syntaxhighlight>
: - Utilizando PowerShell, farémolo do seguinte xeito:
<syntaxhighlight lang="powershell">
PS C:\> $objUser=[ADSI]"LDAP://cn=Andrea,ou=direccion,ou=triton00,dc=triton00,dc=local"
PS C:\> $objUser.setpassword("abc123..")
</syntaxhighlight>
:: Neste caso, a diferencia de outros atributos, non utiliza '''SetInfo''' despois de utilizar '''SetPassword''' para configurar o contrasinal do usuario. Pero, se queremos forzar ao usuario a modificar o contrasinal no seguinte inicio de sesión:
<syntaxhighlight lang="powershell">
PS C:\> $objUser.Put("pwdLastSet",0)
PS C:\> $objUser.setinfo()
</syntaxhighlight>
 
* '''Desbloquear unha conta de usuario:'''
: O bloqueo das contas faise por medio de Directivas, por exemplo, se un usuario non acerta varias veces o seu contrasinal.
: O único xeito de desbloquear unha conta de usuario é facer esta operación directamente na ferramenta gráfica, non hai xeito de facelo nin dende o símbolo de sistema nin con Windows PowerShell.
* '''Deshabilitar e habilitar unha conta de usuario:'''
: As contas de usuario son obxectos de seguridade moi importantes, polo tanto é importante:
: - Non deixar abertas contas de usuario.
: - Configurar directivas e auditorías de contrasinais, e procedementos para asegurarse de que as contas se están utilizando correctamente.
: - Deshabilitar a conta se un usuario se crea antes de que a necesite ou si este estará ausente por un longo período de tempo.
: Pódese deshabilitar unha conta dende o complemento ''Usuarios e equipos de Active Directory'' e tamén empregando o comando [http://technet.microsoft.com/en-us/library/cc732406(v=ws.10).aspx Dsmod]:
<syntaxhighlight lang="powershell">
PS C:\> dsmod user "cn=Andrea,ou=direccion,ou=triton00,dc=triton00,dc=local" -disabled yes
dsmod correcto:cn=Andrea,ou=direccion,ou=triton00,dc=triton00,dc=local
PS C:\>
</syntaxhighlight>
:: Para habilitar unha conta é cuestión de cambiar o '''yes''' por '''no'''.
: '''Con Windows PowerShell''' temos dous xeitos de facelo:
: - Empregando comandos:
<source lang="powershell">
# Deshabilitar:
PS> Disable-ADAccount –Identity andrea
# Habilitar:
PS> Enable-ADAccount –Identity andrea
</source>
: - Ou indirectamente:
<syntaxhighlight lang="powershell">
PS C:\> $objUser=[ADSI]"LDAP://cn=Andrea,ou=direccion,ou=triton00,dc=triton00,dc=local"
PS C:\> $objUser.psbase.InvokeSet('AccountDisabled',$true)
PS C:\> $objuser.setinfo()
</syntaxhighlight>
:: Para habilitar unha conta é cuestión de cambiar o '''$true''' por '''$false'''.
 
* '''Eliminar unha conta de usuario:'''
: Cando unha conta xa non é necesaria, pódese eliminar do AD.
: - Pódense eliminar obxectos de AD empregando o comando [http://technet.microsoft.com/en-us/library/cc731865(v=ws.10).aspx Dsrm], simplemente do seguinte xeito:
<syntaxhighlight lang="powershell">
PS C:\> Dsrm "cn=Andrea,ou=direccion,ou=triton00,dc=triton00,dc=local"
</syntaxhighlight>
:: Observar que '''Dsrm''' non vai seguido pola clase de obxecto usuario (''user'') como nos outros comandos.
: - Para eliminar un usuario de AD utilizando PS farémolo do seguinte xeito:
<syntaxhighlight lang="powershell">
PS C:\> $objOU=[ADSI]"LDAP://ou=direccion,ou=triton00,dc=triton00,dc=local"
PS C:\> $objOU.Delete "user","CN=Andrea"
</syntaxhighlight>
 
* '''Mover unha conta de usuario:'''
: Moitas veces precisaremos mover un obxecto de usuario en AD dunha OU a outra.
: - Pódense mover obxectos de AD empregando o comando [http://technet.microsoft.com/en-us/library/cc731094(v=ws.10).aspx Dsmove], simplemente do seguinte xeito:
<syntaxhighlight lang="powershell">
PS C:\> dsmove "cn=andrea,ou=direccion,ou=triton00,dc=triton00,dc=local" -newparent "ou=programacion,ou=triton00,dc=trit
on00,dc=local"
dsmove correcto:cn=andrea,ou=direccion,ou=triton00,dc=triton00,dc=local
PS C:\>
</syntaxhighlight>
:: Observar que '''Dsmove''' non especifica unha clase de obxecto de usuario.
: - Para mover un usuario de AD utilizando PS farémolo do seguinte xeito:
<syntaxhighlight lang="powershell">
PS C:\> $objUser=[ADSI]"LDAP://cn=andrea,ou=direccion,ou=triton00,dc=triton00,dc=local"
PS C:\> $objUser.psbase.MoveTo("LDAP://ou=programacion,ou=triton00,dc=triton00,dc=local")
</syntaxhighlight>
 
* '''Renomear unha conta de usuario:'''
: As veces nos interesa cambiar o nome de algún usuario, ademais de algún outro parámetro, vexamos como.
: - Podemos empregar o comando [Dsmod] para cambiar algún atributo pero hai que ter en conta que non se poden modificar os atributos ''samAccountName'' e ''CN''.
: - En Windows PowerShell si podemos modificar a propiedade ''CN'':
<syntaxhighlight lang="powershell">
PS C:\> $objUser=[ADSI]"LDAP://cn=andrea,ou=direccion,ou=triton00,dc=triton00,dc=local"
PS C:\> $objUser.psbase.rename("cn=patricia")
</syntaxhighlight>
 
:: Tamén se poden modificar outros atributos do nome, utilizando o método '''Put''' do obxecto de usuario.
 
===== Importar usuarios de xeito masivo =====
 
'''Nota:''' Se precisamos eliminar os acentos dun ''string'' podemos facelo coa función que se implementa no [https://github.com/lazywinadmin/PowerShell/blob/master/TOOL-Remove-StringDiacritic/Remove-StringDiacritic.ps1 seguinte enlace].
 
* '''Importar usuarios con [http://technet.microsoft.com/es-es/library/cc732101(v=ws.10).aspx CSVDE].'''
'''CSVDE''' é unha ferramenta de liña de comandos que importa ou exporta obxectos de AD dende ou cara un arquivo de texto delimitado por comas (.csv). Estes arquivos pódense crear, modificar e abrir con ferramentas tales como o Bloc de Notas, o Calc ou o Excel. É un xeito moi sinxelo de automatizar a creación de contas de usuarios.
 
A sintaxe básica do comando é a seguinte:
: '''csvde [-i] [-f nome de arquivos] [-k]'''
: - O parámetro '''i''' especifica o modo de importación, pois, por defecto, o comando exporta.
: - O parámetro '''f''' identifica o nome do arquivo que se importará ou exportará.
: - O parámetro '''k''' é útil durante as operacións de importación, xa que fai que CSVDE ignore os erros como: ''Obxecto xa existe, Violación de restrición e Atributo ou valor xa existen''.
 
Vexamos un exemplo dun arquivo típico .csv:
<syntaxhighlight lang="text">
DN,objectClass,sAMAccountName,sn,givenName,userPrincipalName
"cn=Brais Piñeiro, ou=direccion, ou=triton00, dc=triton00, dc=local",user,brais,Brais,Piñeiro,brais@triton00.local
"cn=Andrea Torres, ou=direccion, ou=triton00, dc=triton00, dc=local",user,andrea,Andrea,Torres,andrea@triton00.local
</syntaxhighlight>
: Sendo:
:: · '''DN''' : Nome completo no AD.
:: · '''objectClass''' : Pódense importar tamén grupos.
:: · '''sAMAccountName''' : Nome de inicio de sesión de usuario (anterior a Windows 2000).
:: · '''sn''' : Nome de Pila.
:: · '''givenName''' : Apelidos.
:: · '''userPrincipalName''' : Nome de inicio de sesión de usuario.
 
: '''O gran problema desta ferramenta''' é que non pode configurar un contrasinal inicial ao usuario e, polo tanto, estes usuarios están deshabilitados ata que non se lle configure unha. Un xeito de arranxar este problema é facer que o dominio admita contrasinais de '''0 caracteres''', [http://technet.microsoft.com/es-es/library/dd277399.aspx aquí ves cómo configurar así a Directiva de seguridade]. Logo configuramos todas as novas contas para que pidan novo contrasinal no seguinte inicio de sesión, isto é fácil de facer simplemente accedendo á opción Propiedades seleccionando "todas" as contas que nos interesen "á vez".
 
* '''Crear contas de usuario dende un .CSV empregando PowerShell:'''
: - Arquivo usuarios.csv
<source lang="text">
cn;nombre;apellidos;iniciales;ou;dn;dominio;descrip;password;changepwd;letraunidad;directperson;directperfil;scriptinicio;deshabilitada;grupoprin
BraisP;Brais;Piñeiro;BP;ou=ALUMNOS,ou=USUARIOS,ou=IESSANTIAGO,dc=IESSANTIAGO,dc=LOCAL;cn=BraisP,ou=ALUMNOS,ou=USUARIOS,ou=IESSANTIAGO,dc=IESSANTIAGO,dc=LOCAL;IESSANTIAGO.LOCAL;Alumno del IES;abc123..;yes;P:;\\WSERVER1\USUARIOS$\ALUMNOS\BraisP;\\WSERVER1\PERFILES$\BraisP;inicio.bat;no;cn=G-Alumnos,ou=ALUMNOS,ou=USUARIOS,ou=IESSANTIAGO,dc=IESSANTIAGO,dc=LOCAL
MariaR;María;Rodríguez;MR;ou=ALUMNOS,ou=USUARIOS,ou=IESSANTIAGO,dc=IESSANTIAGO,dc=LOCAL;cn=MariaR,ou=ALUMNOS,ou=USUARIOS,ou=IESSANTIAGO,dc=IESSANTIAGO,dc=LOCAL;IESSANTIAGO.LOCAL;Alumno del IES;abc123..;yes;P:;\\WSERVER1\USUARIOS$\ALUMNOS\MariaR;\\WSERVER1\PERFILES$\MariaR;inicio.bat;no;cn=G-Alumnos,ou=ALUMNOS,ou=USUARIOS,ou=IESSANTIAGO,dc=IESSANTIAGO,dc=LOCAL
SoniaL;Sonia;López;SL;ou=ALUMNOS,ou=USUARIOS,ou=IESSANTIAGO,dc=IESSANTIAGO,dc=LOCAL;cn=SoniaL,ou=ALUMNOS,ou=USUARIOS,ou=IESSANTIAGO,dc=IESSANTIAGO,dc=LOCAL;IESSANTIAGO.LOCAL;Alumno del IES;abc123..;yes;P:;\\WSERVER1\USUARIOS$\ALUMNOS\SoniaL;\\WSERVER1\PERFILES$\SoniaL;inicio.bat;no;cn=G-Alumnos,ou=ALUMNOS,ou=USUARIOS,ou=IESSANTIAGO,dc=IESSANTIAGO,dc=LOCAL
MilagrosF;Milagros;Fernández;MF;ou=ALUMNOS,ou=USUARIOS,ou=IESSANTIAGO,dc=IESSANTIAGO,dc=LOCAL;cn=MilagrosF,ou=ALUMNOS,ou=USUARIOS,ou=IESSANTIAGO,dc=IESSANTIAGO,dc=LOCAL;IESSANTIAGO.LOCAL;Alumno del IES;abc123..;yes;P:;\\WSERVER1\USUARIOS$\ALUMNOS\MilagrosF;\\WSERVER1\PERFILES$\MilagrosF;inicio.bat;no;cn=G-Alumnos,ou=ALUMNOS,ou=USUARIOS,ou=IESSANTIAGO,dc=IESSANTIAGO,dc=LOCAL
NoeF;Noé;Fouz;NF;ou=ALUMNOS,ou=USUARIOS,ou=IESSANTIAGO,dc=IESSANTIAGO,dc=LOCAL;cn=NoeF,ou=ALUMNOS,ou=USUARIOS,ou=IESSANTIAGO,dc=IESSANTIAGO,dc=LOCAL;IESSANTIAGO.LOCAL;Alumno del IES;abc123..;yes;P:;\\WSERVER1\USUARIOS$\ALUMNOS\NoeF;\\WSERVER1\PERFILES$\\NoeF;inicio.bat;no;cn=G-Alumnos,ou=ALUMNOS,ou=USUARIOS,ou=IESSANTIAGO,dc=IESSANTIAGO,dc=LOCAL
BreixoG;Breixo;Gómez;BG;ou=ALUMNOS,ou=USUARIOS,ou=IESSANTIAGO,dc=IESSANTIAGO,dc=LOCAL;cn=BreixoG,ou=ALUMNOS,ou=USUARIOS,ou=IESSANTIAGO,dc=IESSANTIAGO,dc=LOCAL;IESSANTIAGO.LOCAL;Alumno del IES;abc123..;yes;P:;\\WSERVER1\USUARIOS$\ALUMNOS\BreixoG;\\WSERVER1\PERFILES$\BreixoG;inicio.bat;no;cn=G-Alumnos,ou=ALUMNOS,ou=USUARIOS,ou=IESSANTIAGO,dc=IESSANTIAGO,dc=LOCAL
LauraL;Laura;López;LL;ou=ALUMNOS,ou=USUARIOS,ou=IESSANTIAGO,dc=IESSANTIAGO,dc=LOCAL;cn=LauraL,ou=ALUMNOS,ou=USUARIOS,ou=IESSANTIAGO,dc=IESSANTIAGO,dc=LOCAL;IESSANTIAGO.LOCAL;Alumno del IES;abc123..;yes;P:;\\WSERVER1\USUARIOS$\ALUMNOS\LauraL;\\WSERVER1\PERFILES$\LauraL;inicio.bat;no;cn=G-Alumnos,ou=ALUMNOS,ou=USUARIOS,ou=IESSANTIAGO,dc=IESSANTIAGO,dc=LOCAL
NuriaL;Nuria;López;NL;ou=ALUMNOS,ou=USUARIOS,ou=IESSANTIAGO,dc=IESSANTIAGO,dc=LOCAL;cn=NuriaL,ou=ALUMNOS,ou=USUARIOS,ou=IESSANTIAGO,dc=IESSANTIAGO,dc=LOCAL;IESSANTIAGO.LOCAL;Alumno del IES;abc123..;yes;P:;\\WSERVER1\USUARIOS$\ALUMNOS\NuriaL;\\WSERVER1\PERFILES$\NuriaL;inicio.bat;no;cn=G-Alumnos,ou=ALUMNOS,ou=USUARIOS,ou=IESSANTIAGO,dc=IESSANTIAGO,dc=LOCAL
AndreaP;Andrea;Pin;AP;ou=ALUMNOS,ou=USUARIOS,ou=IESSANTIAGO,dc=IESSANTIAGO,dc=LOCAL;cn=AndreaP,ou=ALUMNOS,ou=USUARIOS,ou=IESSANTIAGO,dc=IESSANTIAGO,dc=LOCAL;IESSANTIAGO.LOCAL;Alumno del IES;abc123..;yes;P:;\\WSERVER1\USUARIOS$\ALUMNOS\AndreaP;\\WSERVER1\PERFILES$\AndreaP;inicio.bat;no;cn=G-Alumnos,ou=ALUMNOS,ou=USUARIOS,ou=IESSANTIAGO,dc=IESSANTIAGO,dc=LOCAL
RocioP;Rocío;Polín;RP;ou=ALUMNOS,ou=USUARIOS,ou=IESSANTIAGO,dc=IESSANTIAGO,dc=LOCAL;cn=RocioP,ou=ALUMNOS,ou=USUARIOS,ou=IESSANTIAGO,dc=IESSANTIAGO,dc=LOCAL;IESSANTIAGO.LOCAL;Alumno del IES;abc123..;yes;P:;\\WSERVER1\USUARIOS$\ALUMNOS\RocioP;\\WSERVER1\PERFILES$\RocioP;inicio.bat;no;cn=G-Alumnos,ou=ALUMNOS,ou=USUARIOS,ou=IESSANTIAGO,dc=IESSANTIAGO,dc=LOCAL
 
</source>
 
: - Script PowerShell:
<source lang="powershell">
#Dar de alta de forma masiva a Alumnos
#Cabecera de las filas:
###cn;nombre;apellidos;iniciales;ou;dn;dominio;descrip;password;changepwd;
###letraunidad;directperson;directperfil;scriptinicio;deshabilitada;grupoprin
 
$usuarios = Import-Csv C:\scripts\usuarios.csv -Delimiter ";"
 
foreach ($usuario in $usuarios) {
 
  #Damos de alta al usuario con el comando dsadd
  dsadd user ${usuario}.dn -samid ${usuario}.cn -upn "$(${usuario}.cn)@$(${usuario}.dominio)" `
  -fn ${usuario}.nombre -mi ${usuario}.iniciales -ln ${usuario}.apellidos -display ${usuario}.cn `
  -desc ${usuario}.descrip -email "$(${usuario}.cn)@$(${usuario}.dominio)" `
  -pwd ${usuario}.password -mustchpwd ${usuario}.changepwd `
  -hmdrv ${usuario}.letraunidad -hmdir ${usuario}.directperson -profile ${usuario}.directperfil `
  -loscr ${usuario}.scriptinicio -disabled ${usuario}.deshabilitada `
 
  #Creamos el directorio personal del usuario
  New-Item -ItemType directory -Path ${usuario}.directperson
 
  #Configuramos los permisos del directorio personal del usuario
  icacls ${usuario}.directperson /inheritance:d /grant:r "$(${usuario}.cn):(OI)(CI)F"
 
  #Agregamos el usuario a su grupo principal
  dsmod group ${usuario}.grupoprin -addmbr ${usuario}.dn
}
</source>
 
==== Grupos ====
* '''Alcance dos grupos'''
: Para ofrecer máis seguridade temos no AD varios grupos que teñen distinto "alcance".
: O ámbito dun grupo determinado indica que obxectos poden conter ese grupo, limitando a obxectos do mesmo dominio ou permitindo obxectos de outros dominios. Tamén controla onde pode ser utilizado ese grupo, no dominio ou en calquera dominio do bosque.
 
* '''Grupos Locais do Dominio'''
: Grupos Locais do Dominio poden ter no seu interior os seguintes membros:
: - Usuarios
: - Equipos
: - Grupos Globais de calquera Dominio do Bosque
: - Grupos Universais
: - Grupos Locais do mesmo Dominio
: Así, os grupos locais empréganse para asignar permisos a recursos no mesmo dominio ao que pertence ese grupo local.
 
* '''Grupos Globais'''
: Os Grupos Globais poden ter os seguintes membros:
: - Usuarios
: - Equipos
: - Outros Grupos Globais do mesmo dominio
: Pódense empregar Grupos Globais para configurar permisos sobre recursos localizados en calquera dominio dun bosque. Isto pódese conseguir engadindo o grupo global como membro dun grupo local que teña os permisos requiridos.
: Un grupo global pode pertencer a outro grupo global só se os dous están no mesmo dominio.
 
* '''Grupos Universais'''
: Os Grupos Universais poden ter calquera dos seguintes tipos de membros:
: - Usuarios
: - Equipos
: - Grupos Globais de calquera dominio do Bosque
: - Outros Grupos Universais
: Tendo esto en conta, podemos configurar o acceso a obxectos dun dominio do bosque empregando grupos locais facendo que os universais se aniden nestes.
: Pódense empregar tamén grupos universais para configurar permisos a grupos e contas que, ou ben abarcan varios dominios ou todo o bosque.
: Un punto importante no emprego dos grupos universais é que a pertenencia a eles non debe cambiar a menudo, pois os grupos universais son almacenados no [https://technet.microsoft.com/es-es/library/cc730749.aspx catálogo global]. Os cambios de usuarios e grupos pertencentes ao grupo universal son replicados a todos os servidores de catálogo global de bosque. Se estes cambios se realizan a menudo poden consumir moito ancho de banda.
 
* '''Anidamento de grupos'''
: Como discutimos antes, o anidamento de grupos é o feito de agregar un grupo como membro de outro grupo. Por exemplo, cando facemos un grupo global como membro dun grupo universal, dise que se fixo un anidamento a un grupo universal.
: O anidamento de grupos reduce o número de veces que hai que asignar permisos a usuarios en diferentes dominios dun bosque. Por exemplo, se temos múltiples dominios fillos no noso AD, e existen usuarios de cada dominio que precisan acceder a unha base de datos localizada no dominio pai, o xeito máis sinxelo de facelo sería o seguinte:
# Crear un grupo global en cada dominio que conteña todos os usuarios que precisan acceder á base de datos.
# Crear un grupo universal no dominio pai. E logo poñer como membros deste dominio os grupos globais antes creados.
# Agregar o grupo universal a un grupo local para asignarlle os permisos necesarios para acceder á base de datos.
 
: Resumindo, hai que empregar o método: Añadir os '''Contas''' a grupos '''Globais''', añadir os grupos globais a grupos '''Universais''', añadir os grupos universais a grupos '''Locais''' e, finalmente, asignar permisos a eses grupos locais.
 
: '''No caso que máis nos imos atopar, que é, un único dominio nun bosque, o normal é empregar Grupos Globais de Seguridade anidados e, os permisos, directamente aplicados a estes Grupos Globais.'''
 
===== Crear grupos =====
* Para a creación de grupos empregaremos o comando [http://technet.microsoft.com/es-es/library/cc754037(v=ws.10).aspx Dsadd group] tal e como podemos ver a continuación:
<syntaxhighlight lang="powershell">
PS C:\> dsadd group "cn=G-DIRECCION,ou=DIRECCION,ou=TRITON00,dc=TRITON00,dc=LOCAL" -scope g
dsadd correcto:cn=G-DIRECCION,ou=DIRECCION,ou=TRITON00,dc=TRITON00,dc=LOCAL
</syntaxhighlight>
: Facer o anidamento de grupos e introducir os membros deste grupo no seu interior, ainda que tamén se pode facer con este comando, deixarémolo mellor para os comandos [http://technet.microsoft.com/en-us/library/cc732406(v=ws.10).aspx Dsmod].
 
Outro exemplo, pero empregadno os cmdlets '''New-ADGroup''' e '''Set-ADGroup'''.
<source lang="powershell">
PS> New-ADGroup -Name "G-Usuarios" -SamAccountName G-Usuarios -GroupCategory Security -GroupScope Global -DisplayName "G-Usuarios" -Path "OU=Usuarios,OU=SL,DC=sl,DC=local" -Description "Usuarios del dominio SL.local"
PS> New-ADGroup -Name "G-Directores" -SamAccountName G-Directores -GroupCategory Security -GroupScope Global -DisplayName "G-Directores" -Path "OU=Directores,OU=Usuarios,OU=SL,DC=sl,DC=local" -Description "Directores del dominio SL.local"
PS> New-ADGroup -Name "G-Tecnicos" -SamAccountName G-Tecnicos -GroupCategory Security -GroupScope Global -DisplayName "G-Tecnicos" -Path "OU=Tecnicos,OU=Usuarios,OU=SL,DC=sl,DC=local" -Description "Tecnicos del dominio SL.local"
PS> New-ADGroup -Name "G-Programadores" -SamAccountName G-Programadores -GroupCategory Security -GroupScope Global -DisplayName "G-Programadores" -Path "OU=Programadores,OU=Usuarios,OU=SL,DC=sl,DC=local" -Description "Programadores del dominio SL.local"
PS> Add-ADGroupMember -Identity G-Usuarios -Members G-Directores,G-Tecnicos,G-Programadores
</source>
* Se queremos buscar todos os grupos que comezen por 'G-':
<source lang="powershell">
PS>Get-ADGroup  -Filter {name -like "G-*"}
</source>
 
* Tamén podemos facelo con PowerShell:
<syntaxhighlight lang="powershell">
# Conectámonos ao contedor do usuario a crear
PS > $objOU=[ADSI]"LDAP://OU=direccion,ou=triton00,dc=triton00,dc=local"
# Invocamos ao método Create do contedor indicando:
# - O tipo de obxecto a crear: "group"
# - O nome distintivo relativo, RDN: "G-Direccion"
PS > $objGroup=$objOU.Create("group","G-Direccion")
# Configuramos ás propiedades que nos interesen do novo grupo
# para esta tarefa empregamos o método Put.
# - A única obrigatorio sAMAccountName :
PS > $objGroup.Put("sAMAccountName","G-Direccion")
PS >
# Executamos os cambios en AD có método SetInfo do obxecto
PS > $objGroup.SetInfo()
</syntaxhighlight>
: - Por defecto créase un Grupo de Seguridade Global, se quixeramos especificalo:
<syntaxhighlight lang="powershell">
$objGroup.Put("groupType", 0x80000002)
</syntaxhighlight>
: - Se queremos configuralo como Grupo de Seguridade Local:
<syntaxhighlight lang="powershell">
$objGroup.Put("groupType", 0x80000004)
</syntaxhighlight>
 
* Por último, tamén podemos importar grupos con '''CSVDE'''.
: Primeiramente creamos un arquivo .csv que chamaremos '''grupos.csv''':
<syntaxhighlight lang="text">
objectClass, sAMAccountName,DN,member
group,G-Direccion,"cn=G-DIRECCION,ou=DIRECCION,ou=TRITON00,dc=TRITON00,dc=LOCAL",
"cn=Andrea,ou=DIRECCION,ou=TRITON00,dc=TRITON00,dc=LOCAL;
cn=Brais,ou=DIRECCION,ou=TRITON00,dc=TRITON00,dc=LOCAL"
...
</syntaxhighlight>
: Logo, dende a liña de comandos:
<syntaxhighlight lang="powershell">
PS >csvde -i -f c:\scripts\grupos.csv
</syntaxhighlight>
 
===== Anidar grupos e agregarlle membros =====
Para estas tarefas empregaremos o comando [http://technet.microsoft.com/en-us/library/cc732423(v=ws.10).aspx Dsmod group], vexamos algún exemplo interesante:
* '''Anidar grupos:'''
<syntaxhighlight lang="powershell">
# G-DIRECCION será membro de G-TRITON
PS C:\> dsmod group "cn=G-TRITON,ou=TRITON00,dc=TRITON00,dc=LOCAL"
-addmbr "cn=G-DIRECCION,ou=DIRECCION,ou=TRITON00,dc=TRITON00,dc=LOCAL"
 
dsmod correcto:cn=G-TRITON,ou=TRITON00,dc=TRITON00,dc=LOCAL
PS C:\>
</syntaxhighlight>
* '''Agregar varios membros a un grupo existente:'''
<syntaxhighlight lang="powershell">
# andrea e Brais Piñeiro serán membros de G-DIRECCION
PS C:\> dsmod group "cn=G-DIRECCION,ou=DIRECCION,ou=TRITON00,dc=TRITON00,dc=LOCAL"
-addmbr "cn=andrea,ou=DIRECCION,ou=TRITON00,dc=TRITON00,dc=LOCAL"
"cn=Brais Piñeiro,ou=DIRECCION,ou=TRITON00,dc=TRITON00,dc=LOCAL"
 
dsmod correcto:cn=G-DIRECCION,ou=DIRECCION,ou=TRITON00,dc=TRITON00,dc=LOCAL
</syntaxhighlight>
 
* '''Agregar membros a un grupo con PowerShell:'''
: Deste xeito que imos ver podemos anidar grupos ou administrar a pertenencia de usuarios en grupos:
<syntaxhighlight lang="powershell">
#Creamos los grupos
PS > New-ADGroup -Name "G-Usuarios" -SamAccountName G-Usuarios -GroupCategory Security -GroupScope Global -DisplayName "G-Usuarios" -Path "OU=Usuarios,OU=SL,DC=sl,DC=local" -Description "Usuarios del dominio SL.local"
PS > New-ADGroup -Name "G-Directores" -SamAccountName G-Directores -GroupCategory Security -GroupScope Global -DisplayName "G-Directores" -Path "OU=Directores,OU=Usuarios,OU=SL,DC=sl,DC=local" -Description "Directores del dominio SL.local"
PS > New-ADGroup -Name "G-Programadores" -SamAccountName G-Programadores -GroupCategory Security -GroupScope Global -DisplayName "G-Programadores" -Path "OU=Programadores,OU=Usuarios,OU=SL,DC=sl,DC=local" -Description "Programadores del dominio SL.local"
PS >  New-ADGroup -Name "G-Tecnicos" -SamAccountName G-Tecnicos -GroupCategory Security -GroupScope Global -DisplayName "G-Tecnicos" -Path "OU=Tecnicos,OU=Usuarios,OU=SL,DC=sl,DC=local" -Description "Tecnicos del dominio SL.local"
#Anidamiento
PS >  Add-ADGroupMember -Identity G-Usuarios -Members G-Directores,G-Programadores,G-Tecnicos
#Comprobamos anidamiento
PS > Get-ADGroupMember -Identity G-Usuarios | select distinguishedname
 
distinguishedname
-----------------
CN=G-Directores,OU=Directores,OU=Usuarios,OU=SL,DC=sl,DC=local
CN=G-Programadores,OU=Programadores,OU=Usuarios,OU=SL,DC=sl,DC=local
CN=G-Tecnicos,OU=Tecnicos,OU=Usuarios,OU=SL,DC=sl,DC=local
 
</syntaxhighlight>
 
: Para eliminar membros dun grupo faise o mesmo pero se emprega o método ''Remove'' en vez do método ''Add''.
 
* ''Descubrir os Grupos que comecen por "G-":
<source lang="powershell>
PS>Get-ADGroup  -Filter {name -like "G-*"}
</source>
 
* '''Descubrir os membros dun grupo:'''
Empregaremos o cmdlet [https://technet.microsoft.com/en-us/library/ee617193.aspx Get-ADGroupMember]:
<source lang="powershell">
PS>Get-ADGroupMember -Identity "G-Usurios"
...
</source>
* '''Exemplo onde se monta un directorio en concreto se ese usuario pertence a un grupo determinado:'''
:: Supoñer a situación de que si un usuario que inicia sesión nun equipo cliente pertence ao grupo '''G-ADMINISTRACION''' terá montada na unidade '''W:''' o recurso compartido '''\\wserver\facturas$''':
<syntaxhighlight lang="powershell">
# Se o usuario que inicia pertence a G-ADMINISTRACION
# montámoslle o directorio \\wserver\facturas$:
$servidor=wserver
$administ="CN=G-ADMINISTRACION,OU=ADMINISTRACION,OU=USUARIOS,OU=TRITON,DC=TRITON,DC=LOCAL"
$usuario = $env:username
$grupos =  (Get-ADUser -identity $usuario -Properties memberof | Select-Object memberof).memberof
foreach ($grupo in $grupos)
{
if ($grupo -eq $administ)
{
net use W: \\$servidor\facturas$ /persistent:no
}
}
</syntaxhighlight>
:: Recorda que, para que este ''script'' funcione no Cliente Windows 8.1:
:: _ O arquivo inicio.ps1 gardarase no recurso compartido \\wserver\netlogon
:: _ Hai que configurar a ''Set-ExecutionPolicy'' do Windows 8.1 como ''RemoteSigned''  para que poida executar arquivos de PowerShell.
:: _ Hai que asociar os arquivos de extensión .ps1 ao PowerShell empregando a Directiva de grupo correspondente.
:: _ Hai que instalar [http://www.microsoft.com/es-es/download/details.aspx?id=39296 Herramientas de administración remota del servidor para Windows 8,1] para poder empregar o comando ''Get-ADUser'' do ''script''.
::: · [https://www.microsoft.com/es-ES/download/details.aspx?id=45520 Herramientas de administración remota del servidor para Windows 10].
 
===== Mover, Renombrar e Eliminar grupos =====
Para mover ou cambiar o nome dun obxecto podemos empregar o comando '''Dsmove'''.
* '''Para cambiar o nome do grupo G-Instaladores a G-AdminSoft:'''
<syntaxhighlight lang="powershell">
PS >dsmove "cn=G-Instaladores,ou=triton00,dc=triton00,dc=local" -newname "G-AdminSoft"
</syntaxhighlight>
 
* '''Mover un grupo a unha nova ubicación:'''
<syntaxhighlight lang="powershell">
PS >dsmove "cn=G-AdminSoft,ou=triton00,dc=triton00,dc=local" -newparent "ou=Administradores,ou=triton00,dc=triton00,dc=local"
</syntaxhighlight>
 
* '''Para eliminar grupos:'''
Pódese utilizar para esta tarefa o comando '''Dsrm''' para eliminar un grupo (ou calquera outro obxecto de AD):
<syntaxhighlight lang="powershell">
PS >dsrm "cn=G-AdminSoft,ou=Administradores,ou=triton00,dc=triton00,dc=local"
</syntaxhighlight>
 
==== Exemplo de creación dun usuario ====
Exemplo de creación do usuario PIA. Características:
: - Unidade Organizativa: "ou=PROFESORES, ou=USUARIOS, ou=TRITON, dc=TRITON, dc=GA"
: - Conta: "pia"
: - Mail: "pia@triton.ga"
: - Apelidos: "Pérez"
: - Descrición: "Profesor@"
: - Contrasinal: "abc123.." - Ten que cambialo no seguinte inicio de sesión.
: - Carpeta persoal: "\wserver1\usuarios$\profesores\pia" conectada na unidade de rede U:
: - Perfil móbil: "\\wserver1\perfiles$\pia"
: - Script de inicio de sesión: "inicio.ps1"
: - Grupo: "cn=G-PROFESORES, ou=PROFESORES, ou=USUARIOS, ou=TRITON,dc=TRITON,dc=GA"
'''Solución:'''
<syntaxhighlight lang="powershell">
PS> dsadd user "cn=Pia, ou=PROFESORES, ou=USUARIOS, ou=ANIMAMUNDI, dc=ANIMAMUNDI, dc=GA"
-samid pia -upn pia@animamundi.ga -fn Pia -mi PP -ln Pérez -display Pia
-desc "Profesor@" -email pia@gmail.com -pwd abc123.. -mustchpwd yes
-hmdrv U: -hmdir \\wserver1\usuarios$\profesores\pia
-profile \\wserver1\perfiles$\pia -loscr inicio.ps1 -disabled no
PS> mkdir V:\usuarios\profesores\pia
PS> icacls V:\usuarios\profesores\pia /inheritance:d /grant:r "pia:`(OI`)`(CI`)F"
PS> dsmod group "cn=G-PROFESORES, ou=PROFESORES, ou=USUARIOS, ou=ANIMAMUNDI,dc=ANIMAMUNDI,dc=GA"
-addmbr "cn=pia, ou=PROFESORES, ou=USUARIOS, ou=ANIMAMUNDI, dc=ANIMAMUNDI,dc=GA"
</syntaxhighlight>
 
 
==== Administrar equipos ====
===== Crear equipos no AD =====
* A utilidade [https://technet.microsoft.com/es-es/library/cc753708(v=ws.10).aspx Dsadd.exe] permítenos crear Equipos dende a liña de comandos, tal e como se fixo antes cós usuaros. Pódese crear un script empregando esta ferramenta.
: A sintaxe básica é a seguinte:
<source lang="powershell">
PS> dsadd computer WCLIENT00
</source>
 
* Windows PowerShell tamén inclúe o cmdlet [https://technet.microsoft.com/en-us/library/ee617245.aspx New-ADComputer], que nos permite crear equipos coa mesma sintaxe básica. Ollo, pois estas ferramentas crean o boxecto equipo pero non meten o equipo no dominio.
<source lang="powershell">
PS> New-ADComputer -Name "WCLIENT00" -SamAccountName "WCLIENT00" -Path "OU=Clientes,OU=Equipos,OU=IES,DC=IES,DC=LOCAL"
</source>
 
===== Agregar equipos ao dominio =====
Temos distintos xeitos:
* Empregar a utilidade de liña de comandos [https://technet.microsoft.com/en-us/library/cc772217.aspx netdom.exe]:
<source lang="powershell">
PS> netdom join <computername> /Domain:<DomainName> [/UserD:<User> /PasswordD:<UserPassword>] [/OU:OUDN]
</source>
* Agregar equipos polos usuarios de xeito indirecto grazas á ''Default Domain Controlers Policy Group Policy Object'' (GPO) que permite a calquera usuario do dominio agregar ata 10 equipos. Se queremos que un usuario en especial (neste caso "equipator") poida engadir máis de 10 equipos podemos delegar nel ese rol.
* Un script para engadir os equipos no dominio sería o seguinte:
<source lang="powershell">
#Hai que adaptar as seguintes variables
$usuario = "equipator"
$contrasinal = "abc123.."
$dominio = "ies.local"
$password = ConvertTo-SecureString $contrasinal -AsPlainText -Force
$username = $dominio + "\" + $usuario
$myCred = New-Object System.Management.Automation.PSCredential $username, $password
Add-Computer -DomainName  $dominio -Credential $myCred -OUPath "OU=Clientes,OU=Equipos,OU=IES,DC=IES,DC=LOCAL"
 
#Reiniciamos o equipo
Restart-Computer
</source>
 
===== Buscar y mover equipos =====
<syntaxhighlight lang="powershell">
PS> dsquery computer -name wclient00
"CN=WCLIENT00,CN=Computers,DC=ANIMAMUNDI,DC=GA"
PS> dsmove "CN=WCLIENT00,CN=COMPUTERS,DC=ANIMAMUNDI,DC=GA"
-newparent "OU=CLIENTES,OU=EQUIPOS,OU=ANIMAMUNDI,DC=ANIMAMUNDI,DC=GA"
dsmove correcto:CN=WCLIENT00,CN=COMPUTERS,DC=ANIMAMUNDI,DC=GA
PS V:\>
</syntaxhighlight>
 
===== Habilitar e deshabilitar equipos =====
<source lang="powershell">
# Deshabilitar:
PS> Disable-ADAccount –Identity wclient00
# Habilitar:
PS> Enable-ADAccount –Identity wclient00
</source>
 
=== Buscar elementos do AD ===
: Podemos buscar elementos no AD de distintos xeitos, como coas "Consultas gardadas" e o "Botón Atopar da Barra de Ferramentas" do complemento "Usuarios e equipos de AD".
: Có comando [http://technet.microsoft.com/es-es/library/cc732952(v=ws.10).aspx Dsquery] poderemos atopar obxectos de AD.
* O mellor con estes comandos é acudir á axuda:
<syntaxhighlight lang="powershell">
PS C:\> dsquery /?
Descripción: el conjunto de comandos de esta herramienta le permite consultar
el directorio de acuerdo con los criterios especificados. Cada uno de los
siguientes comandos de dsquery busca objetos de un tipo específico, excepto
dsquery *, que puede consultar cualquier tipo de objetos.
 
dsquery computer  - busca equipos en el directorio.
dsquery contact  - busca contactos en el directorio.
dsquery subnet    - busca subredes en el directorio.
dsquery group    - busca grupos en el directorio.
dsquery ou        - busca unidades organizativas en el directorio.
dsquery site      - busca sitios en el directorio.
dsquery server    - busca instancias de DC/LDS de Active Directory en el
                    directorio.
dsquery user      - busca usuarios en el directorio.
dsquery quota    - busca especificaciones de cuota en el directorio.
dsquery partition - busca particiones en el directorio.
dsquery *        - busca cualquier objeto en el directorio con una consulta
                    genérica de LDAP.
 
Para obtener ayuda sobre un comando específico, escriba
"dsquery <tipoObjeto>/?", donde <tipoObjeto> es uno de los tipos de objeto
compatibles mostrados más arriba. Por ejemplo, dsquery ou /?.
...
</syntaxhighlight>
 
* Logo de especificar o tipo de obxecto, pódense utilizar parámetros para indicar criterios da consulta:
: · Polo seu nome: '''-name'''
: · Pola súa descrición: '''-desc'''
: Para ver as propiedades que se requiren:
<syntaxhighlight lang="powershell">
PS C:\> dsquery user /?
Descripción: busca los usuarios en el directorio que coincidan con
ciertos criterios.
 
Sintaxis:  dsquery user [{<nodoInicio> | forestroot | domainroot}]
            [-o {dn | rdn | upn | samid}]
            [-scope {subtree | onelevel | base}]
            [-name <nombre>] [-namep <nombreFonético>]
            [-desc <descripción>] [-upn <UPN>]
            [-samid <nombreSAM>] [-inactive <númSemanas>] [-stalepwd <númDías>]
            [-disabled] [{-s <servidor> | -d <dominio>}] [-u <nombreUsuario>]
            [-p {<contraseña> | *}] [-q] [-gc] [-limit <númObjetos>]
            [{-uc | -uco | -uci}]
</syntaxhighlight>
: Por exemplo, para buscar todos os usuarios que comezan por "b":
<syntaxhighlight lang="powershell">
PS C:\> dsquery user -name b*
"CN=Brais Piñeiro,OU=DIRECCION,OU=TRITON00,DC=TRITON00,DC=LOCAL"
</syntaxhighlight>
: E, se non queremos ver a saída polo seu DN, senón polo seu nome de "inicio de sesión":
<syntaxhighlight lang="powershell">
PS C:\> dsquery user -name b* -o upn
"brais@triton00.local"
</syntaxhighlight>
 
==== Descubrir todos os Grupos existentes dentro dunha UO ====
<syntaxhighlight lang="powershell">
PS > Get-ADGroup -filter * -Properties Distinguishedname |
Select-Object distinguishedname | where {$_ -match "OU=TRITON"}
 
distinguishedname
-----------------
CN=G-USUARIOS,OU=USUARIOS,OU=TRITON,DC=triton,DC=ga
</syntaxhighlight>
 
==== Descubrir todos os Usuarios existentes dentro dunha UO ====
<syntaxhighlight lang="powershell">
PS > Get-ADUser -filter * -Properties Distinguishedname |
Select-Object distinguishedname | where {$_ -match "OU=TRITON"}
 
distinguishedname
-----------------
CN=andrea,OU=USUARIOS,OU=TRITON,DC=triton,DC=ga
</syntaxhighlight>
 
== Enlaces Interesantes ==
:* [http://powershell.com/cs/ PowerShell en PowerShell.com]
:* [http://technet.microsoft.com/scriptcenter/dd742419.aspx PowerShell en Microsoft.com]
:* ...

Revisión actual del 13:01 9 sep 2024

>_

Obtenido de «https://manuais.iessanclemente.net/index.php?title=PowerShell&oldid=70366»