Comandos Powershell em Cluster 2012

Quando falamos em virtualização, a melhor forma para gerenciamento é através do System Center. Agora, caso não se use o system center ou você seja um daqueles que gostam de usar powershell para quase tudo seguem alguns comandos para gerenciamento de VMs em cluster com Windows Server 2012 ou Hyper-V 2012. Esses comandos também funcionam nos 2012 R2:

Dentro de um dos hosts podemos usar os seguintes comandos:

Verificar o nome do cluster:
Get-Cluster

Verificar o Cluster Group:
Get-ClusterGroup

Verificar os nós de um cluster:
Get-ClusterNode

Verificar as VMs em todos os nós do Cluster e em qual nó cada VM está:
Get-ClusterResource | where resourcetype -eq “Virtual Machine” | fl ownergroup, ownernode

Outra forma de verificar as VMs de todos os nós de um cluster:
Get-ClusterNode | foreach ($_.name) {get-vm -computername $_.name}
No caso acima não fica espeficificado em qual host a VM está.

Aqui especifica em qual host cada VM está:
Get-ClusterNode | foreach ($_.name)  {get-vm -computername $_.name | ft vmname, computername}
Um detalhe interessante é que os dois scripts acima verificam todas as VMs em hosts físicos de um cluster, porém, pode acontecer de algumas VMs não estarem clusterizadas.

Para verificar todas as VMs de um cluster usamos o seguinte comando:
Get-ClusterNode | foreach ($_.name)  {get-vm -computername $_.name | where IsClustered -eq $true | ft vmname, computername}

Para ver as VMs que estão em hosts do cluster sem estarem clusterizadas rodamos o comando quase igual ao anterior:
Get-ClusterNode | foreach ($_.name)  {get-vm -computername $_.name | where IsClustered -eq $false | ft vmname, computername}

Verificar as configurações de processador de todas as VMs do Cluster:
Get-ClusterNode | foreach ($_.name)  {get-vm -computername $_.name | Get-VMProcessor}

Verificar as VMs de um cluster onde a compatibilidade do processador para migração entre hosts com processadores de diferentes versões não está habilitada:
Get-ClusterNode | foreach ($_.name)  {get-vm -computername $_.name | Get-VMProcessor | where CompatibilityForMigrationEnabled -eq $false}

Se houver uma ideia de alterar essas VMs que não estão com compatibilidade de processador para o status ativo podemos usar o seguinte comando (lembrando que essa feature só pode ser alterada com a VM desligada, então o script irá desligar as VMs e ligar após a alteração)

$a = Get-ClusterNode | foreach ($_.name)  {get-vm -computername $_.name | Get-VMProcessor | where CompatibilityForMigrationEnabled -eq $false} | foreach ($_.vmname) {$_.vmname}
$b = Get-ClusterNode | foreach ($_.name)  {get-vm -computername $_.name | Get-VMProcessor | where CompatibilityForMigrationEnabled -eq $false} | foreach ($_.vmname) {$_.computername}
Write-Host Atualmente as VMs que não tem compatibilidade de processador para Migracoes sao: $a
foreach ($c in $a)
{stop-vm –computername $b -vmname $c}
foreach ($d in $a)
{Get-VM –computername $b -vmname $d | Set-VMProcessor -CompatibilityForMigrationEnabled 1}
foreach ($e in $a)
{start-vm -computername $b -vmname $e}

Para o comando acima, o ideal seria salvar como .ps1. Alguns erros podem aparecer, pois o script não testa se a vm está em um nó especifico. Esses erros não atrapalham o resultado.

Para verificar a versão do Integration Services das VMs dos hosts do cluster:
Get-ClusterNode | foreach ($_.name) {get-vm -computername $_.name | ft name, integrationservicesversion}

Para verificar as VMs que estão com uma isso montada em todos os hosts do cluster:
Get-ClusterNode | foreach ($_.name) {get-vm -computername $_.name | Get-VMDvdDrive | where path -ne $null | select VMName, path} | foreach ($_.vmname) {$_.vmname}

Para remover a iso montada das VMS em um cluster:
Get-ClusterNode | foreach ($_.name) {get-vm -computername $_.name | Get-VMDvdDrive | where path -ne $null | Set-VMDvdDrive -Path $null} | foreach ($_.vmname) {$_.vmname}

Até a próxima!!

Adicionando um Domain Controller com Windows Server 2012 em uma Floresta existente com PowerShell

Nesse post será mostrado adicionar um servidor com Windows Server 2012 como Domain Controller (DC) em uma Floresta já existente utilizando somente comandos em PowerShell e após fazer a transferência das regras FSMO.

O primeiro passo é logar em um DC e fazer pequenas verificações:
Para verificar informações sobre a floresta:
Get-adforest
Uma dica, para verificar os domínio em uma mesma floresta basta usar os seguintes comandos:
$forest = get-adforest
$forest.domains
Para verificar informações do domínio:
Get-Addomain

O segundo passo é logar no servidor com Windows Server 2012 e que será promovido a DC e adicionar a role de AD DS:
Para Adicionar a Feature de AD DS:
Install-WindowsFeature -name “ad-domain-services” -IncludeAllSubFeature –IncludeManagementTools

Após vamos ingressar no domínio contoso.com:
Install-addsdomaincontroller –installdns –domainname “contoso.com” –credential (get-credential contoso\administrator)
Neste momento deverá ser inserida a senha do usuário administrator do domínio. Após será questionada a senha do DSRM.
Uma vez instalada essa role, o servidor também irá reiniciar.
 
Para verificar onde estão as regras FSMO podemos digitar:
Netdom query fsmo

Para mover as regras FSMO basta digitar:
Move-ADDirectoryServerOperationMasterRole -Identity “SERVIDOR DESTINO” -OperationMasterRole SchemaMaster, RIDMaster, InfrastructureMaster, DomainNamingMaster, PDCEmulator
Caso fosse necessário fazer um seizing das FSMO o comando seria praticamente o mesmo:
Move-ADDirectoryServerOperationMasterRole -Identity “SERVIDOR DESTINO” -OperationMasterRole SchemaMaster, RIDMaster, InfrastructureMaster, DomainNamingMaster, PDCEmulator -force

Até a próxima!!

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!!

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!!