Gerenciando VMs no Hyper-V com PowerShell

Outro grande avanço do Windows Server 2012 foi trazer nativamente comandos PowerShell para o Hyper-V. No Windows Server 2008 R2 é possível gerenciar o servidor através de um módulo baixado do Codeplex: http://pshyperv.codeplex.com/

Neste post será mostrado como fazer o gerenciamento básico de uma VM em um servidor com Hyper-V (Windows Server 2012):

Para verificar informações básicas do host como memória e processadores lógicos basta digitar no PowerShell:
Get-vmhost
Para ver informações mais detalhadas:
get-vmhost | fl
Para verificar se já existem VMs rodando no host:
Get-VM
Bom, o primeiro passo é verificar os adaptadores de rede para criar os switches virtuais.
Para verificar os adaptadores presentes no host digitar:
Get-NetAdapter
Para verificar se existe algum Virtual Switch criado, basta digitar:
Get-VMSwitch
Definido o adaptador e o tipo de switch virtual, basta criar com o comando a seguir: (Será criado um Switch chamado Public_Network utilizando a placa de rede chamada Ethernet, onde estará habilitado o gerenciamento do host e será do tipo externo):
New-VMSwitch –Name “Public_Network” –NetAdapterName “Ethernet” –AllowManagementOS $true
Para criar um switch virtual privado chamado VMSwPr1 poderia ser usado o seguinte comando:
New-VMSwitch –Name “VMSwPr1” –switchtype Private
Para criar uma VM nova o comando simples é:
New-VM
Com o comando acima será criada uma VM nova, com 512 MB de memória fixa, um processador virtual, sem um VHDx atribuído utilizando as pastas padrões do Hyper-V. Seu nome será New Virtual Machine Para saber a pasta padrão onde está sendo criada a VM basta digitar:
Get-VMHost | select VirtualMachinePath, VirtualHardDiskPath
Se foi utilizado o comando acima para criar a VM, para visualizar as configurações basta digitar:
Get-vm -Name new* | fl *
Se a ideia é criar uma VM do zero com configurações específicas e em pastas específicas vamos usar o mesmo comando, só que com parâmetros:
New-VM -Name VMT01 -MemoryStartupBytes 1GB -Path d:\vms –NewVHDPath d:\vms\VMT01\VMT01.vhdx -NewVHDSizeBytes 60GB -SwitchName Public_Network
Com o comando acima foi Criada uma nova VM chamada VMT01, com 1 processador virtual (padrão) e memória fixa de 1 GB. Ainda foi configurado um Adaptador de Rede utilizando o Virtual Switch Public_Network. Foi criado um VHDx novo de 60 GB (mas é dinâmico – até 60 GB) na pasta D:\VMs\VMT01\ chamado VMT01 e o caminho da VM foi colocado como D:\VMs. (A VM cria uma pasta com o próprio nome. Quando a VM é criada seu status é desligada.
Nesse momento é interessante verificar o status dessa nova VM criada:
Get-Vm -Name VMT01 | fl *
Criada a VM ainda existem alguns comandos interessantes. Para essa VM, antes de iniciar, vamos fazer as seguintes alterações:
Mudar de 1 processador virtual para 2:
Get-VM VMT01 | Set-VMProcessor -count 2
Mudar de 1 GB de Memória Fixa para memória dinâmica entre 512 MB e 2 GB sendo 1 GB de inicialização;
Get-VM VMT01 | Set-VMmemory –DynamicMemoryEnabled $true –MaximumBytes 2GB –MinimumBytes 512MB –StartupBytes 1GB
Adicionar a ISO do Windows Server 2012 para a instalação do Windows;
Set-VMDvdDrive -vmname VMT01 -Path ‘D:\ISO\Windows Server 2012\Windows_Server_2012_Datacenter_VL.ISO’
Uma vez feita as alterações a VM está pronta para ser inicializada:
Get-VM VMT01 | Start-VM
Pronto a VM está rodando, pronta para ser utilizada.
Agora vamos supor que nós vamos criar mais um VHDx, chamado VMT01_D2 de 20 GB dinâmico na mesma pasta:
New-VHD -path d:\vms\VMT01\VMT01_D2.vhdx -SizeBytes 20GB
Sò que o VHDx criado acima deveria ser fixo. Para transformar de dinâmico para Fixo podemos usar:
Convert-VHD -path d:\vms\VMT01\VMT01_D2.vhdx –DestinationPath “d:\vms\VMT01\VMT01_D3.vhdx” –VHDtype Fixed
E que tal adicionar esse VHDx na VM criada com ela ligada:
Add-VMHardDiskDrive –Vmname VMT01 –ControllerType SCSI –ControllerNumber 0 –Path d:\vms\VMT01\VMT01_D3.vhdx
Para finalizar os comandos básicos:
Desligar a VM:
Get-VM VMT01 | Stop-VM
Para Suspender a VM:
Get-VM VMT01 | Suspend-VM
Reinicia a VM com Shutdown do SO:
Get-VM VMT01 | Restart-VM
Para Verificar os Snapshots da VM:
Get-VM VMT01 | Get-VMSnapshot
Para criar um Snapshot da VM:
Get-VM VMT01 | Checkpoint-VM
Para renomear um Snapshot:
Get-VM VMT01 | Rename-VMSnapshot –name “VMT01 – (6/18/2013 – 4:39:44 PM)” –newname SNAP1
Para voltar o Snapshot de uma VM:
Get-VM VMT01 | Restore-VMSnapshot –name SNAP1
Para Deletar um Snapshot:
Get-VM VMT01 | Remove-VMSnapshot –name SNAP1
Todos os comando podem ser encontrados em:
http://technet.microsoft.com/en-us/library/hh848559(v=wps.620).aspx

Espero que este post possa ser útil no gerenciamento do seu ambiente Hyper-V 3.0.

Até a próxima!!!

Verificando Serviços em Servidores Remotos

Sem dúvida a melhor forma de se monitorar uma infraestrutura de TI é utilizando o System Center Operations Manager (SCOM). Agora, caso não exista um SCOM em seu ambiente ou ele ainda está em implantação e serviços precisam ser monitorados, isso pode ser feito via PowerShell (PS).

Neste post vai ser mostrado como verificar o status de serviços em um servidor local e em servidores remotos de uma forma simples. Também será mostrado como podem ser feitos scripts um pouco mais elaborados para essas tarefas.

Em um host local para verificar os serviços que estão rodando basta digitar:
Get-Service
0701

Esse comando padrão traz o status do serviço (se está rodando ou não) o nome do serviço e o nome que aparece no Windows de forma amigável.

Em um host para verificar os serviços que estão parados:
Get-Service | where status -eq “stopped”

Em um host para verificar os serviços que estão rodando:
Get-Service | where status -eq “running”

Para poder verificar todos os serviços no servidor remoto (chamado SCVMM2012) precisamos do seguinte comando via PS:
Get-Service –Computername scvmm2012

O próximo comando é utilizado para verificar os serviços que começam com CM:
Get-Service cm* -ComputerName scvmm2012

0702

Para verificar se os serviços em que o nome começa por “cm” estão rodando no servidor remoto:
Get-Service cm* -ComputerName scvmm2012 | Where-Object {$_.status -eq “running”}

Se a ideia é verificar um mesmo serviço em dois servidores diferentes pode ser usado o seguinte comando:
$srv = “scvmm2012”, “scom2012”
Get-Service –Name spooler –Computername $srv

O comando acima vai verificar o status do serviço Spooler nos servidores SCVMM01 e SCOM01.

0703

No caso acima vemos duas vezes o serviço rodando, mas não sabemos em qual está. Se em um estivesse parado iria ser interessante saber em qual dos dois. Para essa situação podemos usar:
$srv = “scvmm2012”, “scom2012”
Get-Service –Name spooler –Computername $srv | format-table –property machinename, status, displayname – auto

Para melhorar um pouquinho mais o detalhamento da saída poderia ser usado ainda:
$srv = “scvmm2012”, “scom2012”
Get-Service –Name spooler –Computername $srv | format-table –property machinename, status, name, displayname – auto

0704

Se a intenção é verificar o serviço de vários servidores uma opção interessante é criar um documento txt com o nome dos servidores, isso facilitaria o trabalho.

O exemplo abaixo mostra um arquivo chamado servers.txt dentro da pasta c:\ps.

0705

Os nomes dos servidores devem estar um em cada linha.
$server = get-content c:\ps\servers.txt
Get-Service –name Spooler –computername $server | format-table –property machinename, status, name, displayname – auto

0706

Uma coisa que pode acontecer é um servidor ser inicializado e algum serviço, que deveria iniciar automaticamente não inicia. Para ver os serviços que devem iniciar de forma automática (no próprio servidor):
Get-WmiObject -Class Win32_Service | where startmode -eq “auto”

O comando acima vai dar um monte de informações. É possível diminuir a quantidade de informações:
Get-WmiObject -Class Win32_Service | where startmode -eq “auto” | Format-Wide -Property Name -Column 1

O comando interessante seria ver os serviços que deveriam iniciar automaticamente e estão parados. Para isso usamos o comando:
Get-WmiObject -Class Win32_Service | where startmode -eq “auto” | where state -eq “stopped”

0707

Para verificar o status de um serviço específico usamos o seguinte comando:
Get-WmiObject -Class Win32_Service | where name –eq skypeupdate

Para iniciar um serviço que esteja parado podemos usar o comando:
Get-WmiObject -Class Win32_Service | where name -eq skypeupdate | start-service

Obviamente para parar um serviço que esteja rodado podemos usar o mesmo comando, apenas mudando o final:
Get-WmiObject -Class Win32_Service | where name -eq skypeupdate | stop-service

0708

Para iniciar todos os serviços que deveriam iniciar automaticamente e estão parados usamos o seguinte comando:
Get-WmiObject -Class Win32_Service | where startmode -eq “auto” | where state -eq “stopped” | start-service

Pensando em vários servidores é possível criar um comando que verifica de uma vez vários serviços em vários servidores. Para esse exemplo usaremos os servidores SCVMM2012 e SCOM2012 e verificaremos o serviço MSSQLSERVER, presente em ambos, e o serviço SCVMMSERVICE presente apenas no servidor SCVMM2012 e o serviço OMSDK presente apenas no servidor SCOM2012:
$srv = “scvmm2012”, “scom2012”
$services = “scvmmservice”, “omsdk”, “mssqlserver”
Get-Service –name $services –computername $srv| format-table –property machinename, status, name, displayname

0709

Para o mesmo exemplo acima, adicionando o serviço de Remote Access, que está parado em ambos servidores:
$srv = “scvmm2012”, “scom2012”
$services = “scvmmservice”, “omsdk”, “mssqlserver”, “remoteaccess”
Get-Service –name $services –computername $srv| format-table –property machinename, status, name, displayname

0710

Agora vamos fazer o seguinte, vamos monitorar os serviços acima, só que vamos mudar o serviço de Remote Access para o serviço de Audio do Windows. O serviço de áudio também está parado nos dois servidores. O próximo comando vai verificar os quatro serviços nos dois servidores e iniciar se algum estiver parado (no caso o serviço de áudio estará parado em ambos:
$srv = “scvmm2012”, “scom2012”
$services = “scvmmservice”, “omsdk”, “mssqlserver”, “audiosrv”
Get-Service –name $services –computername $srv| format-table –property machinename, status, name, displayname
Get-Service –name $services –computername $srv| start-service
Get-Service –name $services –computername $srv| format-table –property machinename, status, name, displayname

O script acima vai mostrar o status dos serviços e após irá iniciar os que estiverem parados e, novamente, irá mostrar o status.

0711

Como fazer essas operações de forma remota fora do domínio no servidor VMM01:
$cred = get-credential
Invoke-Command -ComputerName vmm01 -ScriptBlock {get-service } -credential $cred

0712

Quando o commando $cred = get-credential é digitado, vai abrir uma janela pedindo que seja digitado o usuário e a senha. Para que o usuário seja completado pode ser usado $cred = get-credential contoso\administrator

Que tal criar um script em PowerShell de uma forma um pouco mais elaborada?

Qualquer um dos comandos acima pode ser salvo em um arquivo .ps1 para ser rodado todo de uma vez só. Quando é feito um script podemos aprimorar algumas coisas. Copiar os scripts abaixo e salvar em um arquivo.ps1.

O script abaixo vai verificar os serviços no localhost:
$servers = “localhost”
foreach ($i in $servers)
{write-host “Verificando Serviços no Servidor” $i
Get-wmiobject -computername $servers -class win32_service | Select-Object -property name, state, startmode, startname | sort-object -property startmode, state, name | Format-table *}

O mesmo script verificando os serviços nos servidores SCVMM2012 e SCOM2012:
$servers = “scvmm2012”, “scom2012”
foreach ($i in $servers)
{write-host “Verificando Serviços no Servidor” $i
Get-wmiobject -computername $servers -class win32_service | Select-Object -property name, state, startmode, startname | sort-object -property startmode, state, name | Format-table *}

O script acima não pede credenciais, então deve ser rodado no mesmo domínio.

Que tal um script onde é perguntado o nome do servidor onde verificar o status dos serviços e ainda verifica as credenciais:
$ComputerName = Read-Host “Digite o Nome do Servidor”
$UserName = Read-Host “Digite o Usuario”
$Password = Read-Host -AsSecureString “Digite a Senha”
$Credential = New-Object -TypeName System.Management.Automation.PSCredential -ArgumentList $UserName , $Password
$Service = Get-WmiObject -Class Win32_Service -ComputerName $ComputerName -Credential $Credential
$Service

E agora é dado duas opções de servidores para se escolher:
Write-Host Bem Vindo ao verificador de Serviços. Servidor VMM01 é opção 1. Servidor OM01 é opção 2.
$ComputerName = Read-Host “Digite a opcao”
if ($ComputerName -eq 1)
{
$comp = “vmm01”
}
elseif ($ComputerName -eq 2)
{
$comp = “om01”
}
else
{
Write-Host “Opção inválida”; exit
}
$UserName = Read-Host “Enter User Name”
$Password = Read-Host -AsSecureString “Enter Your Password:”
$Credential = New-Object -TypeName System.Management.Automation.PSCredential -ArgumentList $UserName , $Password
$Service = Get-WmiObject -Class Win32_Service -ComputerName $Comp -Credential $Credential
$Service

Para finalizar, um script que pergunta o nome do host e o tipo de verificação:
Write-Host Bem Vindo ao verificador de Serviços.
$Comp = Read-Host “Digite o nome do Servidor”
Write-Host Tipos de verificação:
Write-Host 1 – Para verificar o status de todos os serviços;
Write-Host 2 – Para verificar os serviços que estão rodando;
Write-Host 3 – Para verificar os serviços que estão parados;
Write-Host 4 – Para verificar os serviços que estão parados e tem inicialização
automática;
Write-Host 5 – Para digitar o nome do serviço a ser verificado;
$vertype = Read-Host “Digite o tipo de verificação”
$UserName = Read-Host “Enter User Name”
$Password = Read-Host -AsSecureString “Enter Your Password”
$Credential = New-Object -TypeName System.Management.Automation.PSCredential -ArgumentList $UserName , $Password
if ($vertype -eq 1)
{
$Service = Get-WmiObject -Class Win32_Service -ComputerName $Comp -Credential $Credential
$Service
}
elseif ($vertype -eq 2)
{
$Service = Get-WmiObject -Class Win32_Service -ComputerName $Comp -Credential $Credential
$Service | where state -eq “running” | format-table -property name, state
}
elseif ($vertype -eq 3)
{
$Service = Get-WmiObject -Class Win32_Service -ComputerName $Comp -Credential $Credential
$Service | where state -eq “stopped” | format-table -property name, state
}
elseif ($vertype -eq 4)
{
$Service = Get-WmiObject -Class Win32_Service -ComputerName $Comp -Credential $Credential
$Service | where startmode -eq “auto” | where state -eq “stopped” | format-table -property name, state
}
elseif ($vertype -eq 5)
{
$Service = Read-Host “Digite o nome do Serviço”
$Service2 = Get-WmiObject -Class Win32_Service -ComputerName $Comp -Credential $Credential | where name -eq $service
$service2
}
else
{
Write-Host “Opção inválida”; exit
}

Antes que alguém fale, eu sei que, no script acima, a verificação da opções deveria vir antes de digitar o usuário e senha.

Depois de todos esses scripts podemos ver como é possível combinar os scripts e criar visualizações diferentes.
Espero que esses scripts possam ser úteis!!!

Até a próxima!!

Delegando acesso para usuários no Hyper-V

É possível delegar funções para usuários administrarem o ambiente de virtualização com o Hyper-V. A maneira mais fácil é usando o System Center Virtual Machine Manager junto com o System Center App Controller. Caso não exista um gerenciamento do ambiente com a família System Center é possível fazer isso individualmente para os servidores.

Vamos supor o caso de um integrante do time de TI que terá a função de acessar o servidor que contém a role do Hyper-V, remotamente, e fazer um gerenciamento de algumas funções das VMs. Essas funções seriam iniciar, desligar, pausar e reiniciar as VMs e ver as configurações atuais da VM. Além disso o usuário poderia acessar a VM, caso tenha permissão para isso.

Inicialmente se um usuário sem permissões de administrador acessar remotamente um servidor com Hyper-V e abrir a console ele terá a imagem a seguir:0601

Essa mensagem quer dizer que o usuário não tem permissão para se conectar no serviço.
Para resolver essa situação é muito simples e será utilizado o Authorization Manager (AzMan) – em português Gerenciador de Autorização.
Para abrir o AzMan basta digitar, no prompt de comando, azman.msc:0602AzMan é um framework de controle de acesso baseado em regras – role-based access control o famoso RBAC. Ele serve para delegar acesso a diversos recursos em diversos níveis além do Hyper-V.

Uma vez aberto teremos a seguinte tela:0603

Para abrir a parte do Hyper-V deve-se ir em Action e Open Authorization Store…:0604

Vai ser questionado o tipo e caminho do Autorization Store. Selecionar XML file e em Store name colocar: %programdata%\Microsoft\Windows\Hyper-V\Initialstore.xml e clicar em OK:0605

Após isso será aberta a seguinte tela:0606

Nesse momento, dentro de Definitions temos a Role Definitions. É possível observar que existe apenas uma regra criada, que é justamente a que libera acesso completo ao Hyper-V, ou seja, uma role de Administrador. Para criar a role para o caso acima é preciso clicar com o botão direito em Role Definitions e selecionar New Role Definition…

Então será questionado o nome da Role. Nesse caso será chamada de Role 01. Na descrição é interessante colocar as informações sobre a regra. Para essa regra está dito que ela vai permitir que o usuário (que posteriormente será associado a ela) terá permissões de desligar e ligar a VM. Não está explícito na descrição, mas faremos com que o usuário possa pausar e reiniciar a VM. Depois de colocada a descrição deve-se ir em Add… para adicionar as definições da regra:0607

Após clicar em Add… é preciso ir em Operations e especificar as operações habilitadas:06080609

Para este caso teremos as seguintes operações:0610

Detalhando um pouco melhor o que cada uma das sete Definições habilita ao usuário:

  • Allow Input to Virtual Machine – Esse comando vai permitir que o usuário possa fazer as ações sobre a VM, como por exemplo enviar o comando de Ctrl+Alt+Del;
  • Allow Output from Virtual Machine – Esse comando é o que vai habilitar o usuário a ver a tela da VM;
  • Pause and Restart Virtual Machine – Comando que habilita o usuário a dar os comandos de pause e reinicio para a VM;
  • Read Service Configuration – É a definição que habilita o usuário a se conectar ao serviço do Hyper-V;
  • Start Virtual Machine – Comando que habilita o usuário a iniciar uma VM;
  • Stop Virtual Machine – Comando que habilita o usuário a desligar uma VM;
  • View Virtual Machine Configuration – Permite ao usuário ver as configurações da VM.

Algumas considerações:
Na opção para ver as configurações da VM o usuário não conseguirá ver alguns detalhes como o Switch Virtual Associado, isso deve ser habilitado como outra definição.
Muitas definições dependem de outras. Exemplo: O start VM não funciona se o Allow Input to Virtual Machine e ainda é preciso do Allow Output from VM para se poder ver o resultado na tela.
No link abaixo existe um detalhamento sobre os operadores a serem liberados em cada necessidade:
http://technet.microsoft.com/en-us/library/dd282980(v=ws.10).aspx

Finalmente será preciso associar o usuário a esta regra criada. Para isso é preciso ir em Role Assignments clicar com o botão direito e selecionar New Role Assignment…0611

Feito isso deve ser selecionado o nome da regra criada:0612

Após basta clicar com o botão direito no nome da regra em Role Assignments, escolher Assign Users and Groups e escolher From Windows and Active Directory. Feito isso basta escolher o usuário ou grupo.0613

Neste momento o usuário possui acesso ao Hyper-V para as tarefas deste caso. Se o usuário estiver logado no servidor não precisa efetuar um logoff, basta dar um refresh no Hyper-V Manager.

Até a próxima!!

Monitorando Máquinas Virtuais

Resource Metering é uma das novas features do Windows Server 2012. Sua função é monitorar máquinas virtuais (VMs) quanto ao uso de CPU, Memória, espaço em disco e rede.
Sete métricas podem ser coletadas por este recurso:
• Uso médio de CPU por uma VM;
• Uso médio de Memória por uma VM;
• Mínimo de Memória usada por uma VM;
• Máximo de Memória usada por uma VM;
• Máximo de espaço em disco alocado para uma VM;
• Tráfego total de entrada por um adaptador de rede virtual;
• Tráfego total de saída por um adaptador de rede virtual;

Para habilitar o Resource Metering em uma VM (neste caso chamada FTP01) basta digitar no host Hyper-V dessa VM:

Enable-VMResourcemetering –VMName FTP01

0501

Quando este comando é dado para uma VM os contadores começam a rodar. Para mostrar o resultado, basta rodar o seguinte comando:

Measure-VM –Vmname FTP01 ou ainda Measure-VM –Vmname FTP01 | fl

0502

Para demonstrar o tráfego de entrada copiei um arquivo para dentro da VM, pela imagem abaixo é possível ver o tráfego (em magabytes) aumentando.

0503

É interessante dizer que as estatísticas perduram mesmo que a VM seja reiniciada ou desligada. Mesmo se ocorrer um Live Migration ou Storage Migration as estatiscas não são perdidas.

Para resetar as estatísticas deve ser usado o comando:
Reset-VMResourceMetering –VMName FTP01

Para parar a coleta de estatísticas basta dar o comando:
Disable-VMResourcemetering –VMName FTP01

Outra coisa interessante é rodar este comando de um servidor remoto. Do servidor B09 para pegar as estatíscas da VM FTP01 no servidor B10 basta digitar:
Measure-VM –Computername B10 –vmname FTP01

Para saber, dentro de um host Hyper-V, quais VMs estão com os contadores ativados, basta dar o seguinte comando:
Get-VM | format-list name,resourcemeteringenabled

Para salvar as estatísticas da VM FTP01 em um arquivo CSV podemos usar os seguintes comandos:
$repVM = get-vm ftp01 | measure-vm
$repVM | Export-Csv -NoTypeInformation -Path c:\reports\report-ftp01.csv

Para finalizar, também é possível criar um pool de monitoramento juntando várias VMs.
Para ver as estatísticas de uso de memórias de duas VMs devemos fazer o seguinte:

Get-VMResourcePool – Este comando vai mostrar os pools disponíveis.
New-VMResourcePool –Name MemoryPool1 –ResourcePoolType Memory – Este comando vai criar um novo pool de memória chamado MemoryPool1.
Get-VM -name FTP01,TST_01 | Stop-VM – Este comando vai desligar as VMs FTP01 e TST_01 que servirão para mostrar o uso do pool. Elas precisam estar desligadas para o próximo comando.
Set-VMMemory -VMName FTP01,TST_01 – ResourcePoolName MemoryPool1 – Seta as duas VMs para usarem o Pool MemoryPool1, recém criado.
Enable-VMResourcemetering -VMName FTP01,TST_01 – Habilita a coleta de estatísticas das duas VMs.
Get-VM -name FTP01,TST_01 | Start-VM – inicia as VMs.
Measure-VMResourcePool –Name MemoryPool1 – Mostra as estatísticas, neste caso de memória e das duas VMs.

Esses comandos podem ser conferidos na figura abaixo:

0504

Até a próxima!!