---
title: VMware Guest
slug: homologacao-atmosphere/vmware-guest
description: Learn how to create, manage, and customize virtual machines in a VMware environment using the PyVmomi module with this comprehensive document. Explore power states, instance UUIDs, disk and CD-ROM configurations, OS customization options, hardware virtual
docTags: 
createdAt: 2023-03-10T20:02:16.000Z
---

## Resumo

Este módulo pode ser usado para criar novas máquinas virtuais a partir de modelos ou outras máquinas virtuais, gerenciar o estado de energia da máquina virtual, como ligar, desligar, suspender, desligar, reiniciar, reiniciar etc., modificar vários componentes da máquina virtual, como rede, disco, personalização, etc., renomeie uma máquina virtual e remova uma máquina virtual com componentes associados.

## Requisitos

Os requisitos abaixo são necessários no host que executa este módulo.

- PyVmomi

## Parâmetros

| **Parâmetro**                     | **Tipo**                   | **Escolhas \| Valor&#x20;*****Padrão***                                                                                                                                                                                  | **Comentários**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| --------------------------------- | -------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| state                             |  string                    | - ***absent***
- poweredon&#x20;
- powered-on&#x20;
- poweredoff&#x20;
- powered-off&#x20;
- present&#x20;
- rebootguest&#x20;
- reboot-guest&#x20;
- restarted
- suspended&#x20;
- shutdownguest&#x20;
- shutdown-guest | <br />- Especifique o estado em que a máquina virtual deve estar.
- Se C(estado) for definido como C(presente) e a máquina virtual existir, certifique-se de que as configurações da máquina virtual estejam em conformidade com os argumentos da tarefa.
- Se C(estado) for definido como C(ausente) e a máquina virtual existir, a máquina virtual especificada será removida com seus componentes associados.
- Se C(estado) for definido como um dos seguintes C(ligado), C(ligado), C(desligado), C(desligado),&#xA;C(presente), C(reiniciado), C(suspenso) e a máquina virtual não existe, a máquina virtual é implantada com os parâmetros fornecidos.
- Se C(estado) estiver definido como C(ligado) ou C(ligado) e a máquina virtual existir com estado de energia diferente de ligado,&#xA;então a máquina virtual especificada é ligada.
- Se C(estado) estiver definido como C(desligado) ou C(desligado) e a máquina virtual existir com estado de energia diferente de desligado,&#xA;então a máquina virtual especificada é desligada.
- Se C(estado) for definido como C(reiniciado) e a máquina virtual existir, a máquina virtual será reiniciada.
- Se C(estado) for definido como C(suspenso) e a máquina virtual existir, a máquina virtual será definida como modo suspenso.
- Se C(estado) estiver definido como C(shutdownguest) ou C(shutdown-guest) e a máquina virtual existir, a máquina virtual será desligada.
- Se C(state) for definido como C(rebootguest) ou C(reboot-guest) e a máquina virtual existir, a máquina virtual será reinicializada.
- Powerstate C(ligado) e C(desligado) adicionado na versão 2.10. |
| name                              | string                     |                                                                                                                                                                                                                          | Nome da máquina virtual.<br /><br />Este é um parâmetro obrigatório, se o parâmetro `uuid` ou `moid` não for fornecido.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| name\_match                       | string                     | * ***first***
* last                                                                                                                                                                                                     | Se várias máquinas virtuais corresponderem ao nome, use a primeira ou a última encontrada                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| uuid                              | string                     |                                                                                                                                                                                                                          | UUID da instância para reunir fatos, se conhecido, este é o identificador exclusivo da VMware.<br /><br />Este é um parâmetro obrigatório, se o parâmetro `name` ou `moid` não for fornecido.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| use\_instance\_uuid               | bool                       | - ***False***
- True                                                                                                                                                                                                     | Se deve usar o UUID da instância VMware em vez do UUID do BIOS                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| template                          | string                     |                                                                                                                                                                                                                          | <br />- Modelo ou máquina virtual existente usada para criar uma nova máquina virtual.&#x20;
- Se este valor não for definido, a máquina virtual será criada sem usar um modelo.
- Se a máquina virtual já existir, este parâmetro será ignorado.
- Este parâmetro diferencia maiúsculas de minúsculas.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| is\_template                      | bool                       | * ***False***
* True                                                                                                                                                                                                     | <br />* Sinalize a instância como um modelo.&#x20;
* Isso marcará a máquina virtual fornecida como modelo.&#x20;
* Observe que isso pode precisar ser feito em uma chamada de tarefa dedicada que não está fazendo quaisquer outras alterações. Por exemplo, o usuário não pode alterar o estado de ligado para desligado E salve como modelo na mesma tarefa.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| folder                            | string                     |                                                                                                                                                                                                                          | Pasta de destino, caminho absoluto ou relativo para encontrar um convidado existente.<br /><br />Este é um parâmetro obrigatório, apenas se várias VMs forem encontradas com o mesmo nome.<br /><br />A pasta deve incluir o datacenter. <br /><br />O datacenter da ESX é ha-datacenter<br /><br />Exemplos:<br />folder: /ha-datacenter/vm<br />folder: ha-datacenter/vm<br />folder: /datacenter1/vm<br />folder: datacenter1/vm<br />folder: /datacenter1/vm/folder1<br />folder: datacenter1/vm/folder1<br />folder: /folder1/datacenter1/vm<br />folder: folder1/datacenter1/vm<br />folder: /folder1/datacenter1/vm/folder2                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| hardware                          | dict                       |                                                                                                                                                                                                                          | - - Gerenciar os atributos de hardware da máquina virtual."
- Todos os parâmetros diferenciam maiúsculas de minúsculas.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| guest-id                          | string                     |                                                                                                                                                                                                                          | * Defina o ID do convidado.&#x20;
* Este parâmetro diferencia maiúsculas de minúsculas.&#x20;
* C(rhel7\_64Guest) para máquina virtual com RHEL7 de 64 bits.&#x20;
* C(centos64Guest) para máquina virtual com CentOS 64 bits.&#x20;
* C(ubuntu64Guest) para máquina virtual com Ubuntu 64 bits.&#x20;
* Este campo é obrigatório ao criar uma máquina virtual, não é obrigatório ao criar a partir do modelo. ->&#x20;
* Os valores válidos são referenciados aqui: U([https://code.vmware.com/apis/358/doc/vim.vm.GuestOsDescriptor.GuestOsIdentifier.html](https://code.vmware.com/apis/358/doc/vim.vm.GuestOsDescriptor.GuestOsIdentifier.html))                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| use\_instance\_uuid               | boolean                    | - ***False***
- True                                                                                                                                                                                                     | Se deve usar o UUID da instância do VMware em vez do UUID do BIOS.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| disk                              | list / elements=dictionary | <br />                                                                                                                                                                                                                   | * Uma lista de discos a serem adicionados.
* As informações relacionadas ao disco virtual são fornecidas usando esta lista.
* Todos os valores e parâmetros diferenciam maiúsculas de minúsculas.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| nvdimm                            | dict                       |                                                                                                                                                                                                                          | - Adicione ou remova um dispositivo NVDIMM virtual da máquina virtual.&#x20;
- A versão do hardware virtual da VM deve ser 14 ou superior no vSphere 6.7 ou posterior.
- Verifique se o sistema operacional convidado da máquina virtual suporta PMem antes de adicionar o dispositivo NVDIMM virtual.
- Verifique se você tem o privilégio de espaço I(Datastore.Allocate) na máquina virtual.
- Certifique-se de que o host ou cluster no qual a máquina virtual reside tenha recursos PMem disponíveis.
- Para adicionar ou remover o dispositivo NVDIMM virtual à máquina virtual existente, ela deve estar desligada.<br />                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| cdrom                             | raw                        |                                                                                                                                                                                                                          | *  Uma lista de configurações de CD-ROM para a máquina virtual. Adicionado na versão 2.9.
* O fornecimento de configuração de CD-ROM como dict está obsoleto e será removido da coleção VMware 4.0.0. Em vez disso, use uma lista.
* 'Parâmetros C(controller\_type), C(controller\_number), C(unit\_number), C(state) são adicionados para uma lista de CD-ROMs suporte de configuração.'
* Para o controlador C(ide), o CD-ROM hot-add ou hot-remove não é suportado.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| resource\_pool                    | string                     |                                                                                                                                                                                                                          | - Use o pool de recursos fornecido para a operação da máquina virtual.
- Este parâmetro diferencia maiúsculas de minúsculas.
- O pool de recursos deve ser filho do pai do host selecionado.
- Quando não especificado, I(Recursos) é considerado como valor padrão.<br />                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| wait\_for\_ip\_address            | bool                       | * ***False***
* True                                                                                                                                                                                                     | - Aguarde até que o vCenter detecte um endereço IP para a máquina virtual.
- Isso requer vmware-tools (vmtoolsd) para funcionar corretamente após a criação.
-  "vmware-tools precisa ser instalado na máquina virtual fornecida para funcionar com este parâmetro."                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| wait\_for\_ip\_address\_timeout   | interger                   | * ***300***                                                                                                                                                                                                              | - Defina um tempo limite (em segundos) para o parâmetro wait\_for\_ip\_address.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| wait\_for\_customization\_timeout | interger                   | * ***3600***                                                                                                                                                                                                             | - Defina um tempo limite (em segundos) para o parâmetro wait\_for\_customization.
- Tenha cuidado ao definir esse valor, pois o tempo de personalização do convidado pode diferir entre os sistemas operacionais convidados.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| wait\_for\_customization          | bool                       | * ***False***
* True                                                                                                                                                                                                     | - Aguarde até que o vCenter detecte que todas as personalizações de convidado foram concluídas com êxito.
- Quando habilitada, a VM será ligada automaticamente.
- "Se o vCenter não detectar o início ou o êxito da personalização do convidado, os eventos com falha após o tempo parâmetro C(wait\_for\_customization\_timeout) especificado, uma mensagem de aviso será impressa e o resultado da tarefa será reprovado."                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| state\_change\_timeout            | interger                   | * ***0***                                                                                                                                                                                                                | - Se C(estado) for definido como C(shutdownguest), por padrão o módulo retornará imediatamente após o envio do sinal de desligamento.
- Se este argumento for definido como um número inteiro positivo, o módulo aguardará até que a máquina virtual atinja o estado desligado.
- O valor define um tempo limite em segundos para o módulo aguardar a mudança de estado.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| snapshot\_src                     | string                     |                                                                                                                                                                                                                          | * Nome do instantâneo existente a ser usado para criar um clone de uma máquina virtual.
* Este parâmetro diferencia maiúsculas de minúsculas.
* Ao criar um clone vinculado usando o parâmetro C(linked\_clone), esse parâmetro é obrigatório.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| linked\_clone                     | bool                       | - ***False***
- True                                                                                                                                                                                                     | * Se deve criar um clone vinculado a partir do instantâneo especificado.
* Se especificado, então C(snapshot\_src) é o parâmetro obrigatório.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| force                             | bool                       | - ***False***
- True                                                                                                                                                                                                     | * Ignore os avisos e conclua as ações.
* Este parâmetro é útil ao remover a máquina virtual que está ligada.
* 'Este módulo reflete a API do VMware vCenter e o fluxo de trabalho da interface do usuário, como tal, em alguns casos, o sinalizador \`force\` seja obrigatório executar a ação para garantir que você tenha certeza de que a ação deve ser executada, independentemente da consequência. Este é especificamente o caso de remover uma máquina virtual ligada quando C(estado) é definido como C(ausente).'                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| delete\_from\_inventory           | bool                       | - ***False***
- True                                                                                                                                                                                                     | * Excluir a máquina virtual do inventário ou excluir do disco.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| datacenter                        | string                     | - ***ha-datacenter***                                                                                                                                                                                                    | * Datacenter de destino para a operação de implantação.
* Este parâmetro diferencia maiúsculas de minúsculas.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| cluster                           | string                     |                                                                                                                                                                                                                          | - O nome do cluster no qual a máquina virtual será executada.
- Este é um parâmetro obrigatório, se C(esxi\_hostname) não estiver definido.
- C(esxi\_hostname) e C(cluster) são parâmetros mutuamente exclusivos.
- Este parâmetro diferencia maiúsculas de minúsculas.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| esxi\_hostname                    | string                     |                                                                                                                                                                                                                          | * O nome do host ESXi onde a máquina virtual será executada.
* Este é um parâmetro obrigatório, se C(cluster) não estiver definido.
* C(esxi\_hostname) e C(cluster) são parâmetros mutuamente exclusivos.
* Este parâmetro diferencia maiúsculas de minúsculas.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| advanced\_settings                | list                       |                                                                                                                                                                                                                          | - Defina uma lista de configurações avançadas a serem adicionadas à configuração do VMX.
- Um objeto de configurações avançadas ocupa dois campos C(chave) e C(valor).
- Chave e valores incorretos serão ignorados.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| annotation                        | string                     |                                                                                                                                                                                                                          | * Uma nota ou anotação para incluir na máquina virtual.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| customvalues                      | list                       |                                                                                                                                                                                                                          | - Defina uma lista de valores personalizados para definir na máquina virtual.
- Um objeto de valor personalizado usa dois campos C(chave) e C(valor).
- Chave e valores incorretos serão ignorados.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| networks                          | list                       |                                                                                                                                                                                                                          | * Uma lista de redes (na ordem das NICs).
* A remoção de NICs não é permitida durante a reconfiguração da máquina virtual.
* Todos os parâmetros e nomes de objetos VMware diferenciam maiúsculas de minúsculas.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| customization                     | dict                       |                                                                                                                                                                                                                          | - Parâmetros para personalização do sistema operacional ao clonar do modelo ou da máquina virtual ou aplicar diretamente à máquina virtual existente.
- Nem todos os sistemas operacionais são compatíveis com a personalização com a respectiva versão do vCenter, verifique a documentação do VMware para a respectiva personalização do sistema operacional.&#x20;
- Para matriz de sistema operacional de personalização compatível, (consulte U([http://partnerweb.vmware.com/programs/guestOS/guest-os-customization-matrix.pdf](http://partnerweb.vmware.com/programs/guestOS/guest-os-customization-matrix.pdf)))
- Todos os parâmetros e nomes de objetos VMware diferenciam maiúsculas de minúsculas.
- Os sistemas operacionais baseados em Linux requerem que o pacote Perl seja instalado para personalizações do sistema operacional.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| vaap\_properties                  | list/dict                  |                                                                                                                                                                                                                          | * Uma lista de propriedades do vApp.
* 'Para obter a lista completa de atributos e tipos, consulte: U([https://code.vmware.com/apis/704/vsphere/vim.vApp.PropertyInfo.html](https://code.vmware.com/apis/704/vsphere/vim.vApp.PropertyInfo.html))'                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| customization\_spec               | string                     |                                                                                                                                                                                                                          | - Nome exclusivo que identifica a especificação de customização solicitada.
- Este parâmetro diferencia maiúsculas de minúsculas.
- Se definido, substitui os valores do parâmetro C (personalização).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| datastore                         | string                     |                                                                                                                                                                                                                          | * Especifique o armazenamento de dados ou o cluster de armazenamento de dados para provisionar a máquina virtual.
* Este parâmetro tem precedência sobre o parâmetro C(disk.datastore).&#xA;Este parâmetro pode ser usado para substituir a configuração do armazenamento de dados ou cluster de armazenamento de dados da máquina virtual quando implantado a partir do modelo.
* Por favor, veja o exemplo para mais uso.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| convert                           | string                     | - thin
- thick
- eagerzeroedthick                                                                                                                                                                                        | * Especifique o tipo de disco de conversão durante a clonagem do modelo ou da máquina virtual.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |

Este módulo utiliza fragmentos da documentação do módulo [VMware Options](https://app.archbee.com/docs/qhqZWWA92JYWAihQOL_T5/lUq5eineIhH7ZwvyWZYCa).



## Sub-options de hardware

| **Parâmetro**                | **Tipo** | **Escolhas \| Valor&#x20;*****Padrão***           | **Comentários**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| ---------------------------- | -------- | ------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| hotadd\_cpu                  |  bool    |                                                   | Permitir que CPUs virtuais sejam adicionadas enquanto a máquina virtual está em execução                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| hotremove\_cpu               | bool     |                                                   | Permitir que as CPUs virtuais sejam removidas enquanto a máquina virtual estiver em execução                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| hotadd\_memory               | bool     | ******                                            | Permitir que a memória seja adicionada enquanto a máquina virtual está em execução                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| memory\_mb                   | interger | <br />                                            | Quantidade de memória em MB                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| num\_cpus                    | interger |                                                   | - Número de CPUs.&#x20;
- C(num\_cpus) deve ser um múltiplo de C(num\_cpu\_cores\_per\_socket).&#x20;
- Por exemplo, para criar uma VM com 2 soquetes de 4 núcleos, especifique C(num\_cpus) como 8 e C(num\_cpu\_cores\_per\_socket) como 4.                                                                                                                                                                                                                                                                                                                                                                                                                    |
| num\_cpu\_cores\_per\_socket | interger |                                                   | Número de núcleos por soquete<br />                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| scsi                         | string   | * buslogic
* lsilogic
* lsilogicsas
* paravirtual | - Os valores válidos são C(buslogic), C(lsilogic), C(lsilogicsas) e C(paravirtual).&#x20;
- C(paravirtual) é o padrão.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| secure\_boot                 | bool     |                                                   | Se deve ativar ou desativar a inicialização segura (U)EFI                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| memory\_reservation\_lock    | bool     |                                                   | Se definido C(true), reserva de recurso de memória para a máquina virtual                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| max\_connections             | interger |                                                   | Número máximo de conexões de exibição remota ativas para as máquinas virtuais                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| mem\_limit                   | interger |                                                   | * A utilização de memória de uma máquina virtual não excederá esse limite.&#x20;
* A unidade é MB.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| mem\_reservation             | interger |                                                   | A quantidade de recurso de memória garantidamente disponível para a máquina virtual                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| cpu\_limit                   | interger |                                                   | - A utilização da CPU de uma máquina virtual não excederá esse limite.
- A unidade é MHz.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| cpu\_reservation             | interger |                                                   | A quantidade de recursos da CPU garantidamente disponível para a máquina virtual                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| version                      | string   |                                                   | <br />- As versões de hardware da máquina virtual.&#x20;
- O padrão é 10 (ESXi 5.5 e posteriores).&#x20;
- Se definido como C(latest), a máquina virtual especificada será atualizada para a versão de hardware mais atual suportada no host.
- Verifique a documentação do VMware para obter a versão correta do hardware da máquina virtual.
- A versão de hardware incorreta pode levar à falha na implantação. Se a versão do hardware já for igual à fornecida.                                                                                                                                                                                             |
| boot\_firmware               | string   | * bios
* efi                                      | Escolha qual firmware deve ser usado para inicializar a máquina virtual                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| nested\_virt                 | bool     |                                                   | Habilitar virtualização aninhada                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| virt\_based\_security        | bool     |                                                   | <br />* Habilitar o recurso de segurança baseada em virtualização para Windows no ESXi 6.7 e posterior, da versão de hardware 14.&#x20;
* Os sistemas operacionais convidados suportados são Windows 10 de 64 bits, Windows Server 2016, Windows Server 2019 e posterior.&#x20;
* O firmware da máquina virtual deve ser EFI e a inicialização segura deve estar habilitada.&#x20;
* A segurança baseada em virtualização depende da virtualização aninhada e da tecnologia de virtualização Intel para E/S direcionada.&#x20;
* Implantar em ESXi sem suporte, versão de hardware ou firmware pode levar a falha ou VM implantada com configurações inesperadas |
| iommu                        | bool     |                                                   | Sinalizador para especificar se I/O MMU está ativado para esta máquina virtual                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |

## Sub-options de disk

| **Parâmetro**         | **Tipo** | **Escolhas \| Valor&#x20;*****Padrão***                                    | **Comentários**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| --------------------- | -------- | -------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| size                  |  string  | - Disk storage size.
- Please specify storage unit like \[kb, mb, gb, tb]. | Tamanho de armazenamento do disco na unidade especificada.<br />Se `size` especificado, a unidade deve ser especificada. Não há espaço permitido entre o número do tamanho e a unidade.<br />Apenas a primeira ocorrência no elemento de disco será considerada, mesmo se houver vários parâmetros de tamanho \* disponíveis.                                                                                                                                                                                                                     |
| size\_kb              | interger |                                                                            | Tamanho do armazenamento do disco em kb                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| size\_mb              | bool     | ******                                                                     | Tamanho do armazenamento do disco em mb                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| size\_gb              | interger | <br />                                                                     | Tamanho do armazenamento do disco em gb                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| size\_tb              | interger |                                                                            | Tamanho do armazenamento do disco em tb                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| type                  | interger | * thin
* thick
* eagerzeroedthick                                          | - Tipo de disco.&#x20;
- Se C(thin) for especificado, o tipo de disco será definido como thin disk.&#x20;
- Se não for especificado, o tipo de disco é herdado da VM ou modelo de origem quando clonado e disco grosso, caso contrário, não ansioso<br />                                                                                                                                                                                                                                                                                         |
| datastore             | string   |                                                                            | * O nome do armazenamento de dados que será usado para o disco.&#x20;
* Se C(autoselect\_datastore) for definido como True, selecionará o armazenamento de dados menos usado cujo nome contém esta string "disk.datastore"                                                                                                                                                                                                                                                                                                                        |
| filename              | string   |                                                                            | - Imagem de disco existente a ser usada.&#x20;
- O nome do arquivo já deve existir no armazenamento de dados.                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| autoselect\_datastore | bool     |                                                                            | * Selecione o armazenamento de dados menos usado.&#x20;
* C(disk.datastore) e C(disk.autoselect\_datastore) não serão usados ​​se C(datastore) for especificado fora desta configuração C(disk)                                                                                                                                                                                                                                                                                                                                                   |
| disk\_mode            | string   | - persistent
- independent\_persistent
- independent\_nonpersistent        | Número máximo de conexões de exibição remota ativas para as máquinas virtuais                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| controller\_type      | string   | * buslogic
* lsilogic
* lsilogicsas
* paravirtual
* sata
* nvme            | - Tipo de controlador de disco.
- O suporte ao tipo de controlador C(nvme) começa no ESXi 6.5 com versão de hardware VM C(versão) 13. Definir esse tipo como versão de hardware ESXi ou VM não suportada resultará em falha na implantação.
- Quando definido como C(sata), certifique-se de que C(unit\_number) esteja correto e não seja usado por CD-ROMs SATA.
- Se definido como tipo C(sata), certifique-se de que C(controller\_number) e C(unit\_number) estejam definidos corretamente quando C(cdrom) também definido como tipo C(sata) |
| controller\_number    | interger | * 0
* 1
* 2
* 3                                                            | - Número do barramento do controlador de disco.&#x20;
- O número máximo de controladores do mesmo tipo é 4 por VM.                                                                                                                                                                                                                                                                                                                                                                                                                                |
| unit\_number          | interger |                                                                            | <br />- Número da unidade de disco.&#x20;
- Intervalo de valores válidos de 0 a 15 para controlador SCSI, exceto 7.&#x20;
- Intervalo de valores válidos de 0 a 14 para o controlador NVME.&#x20;
- Intervalo de valores válidos de 0 a 29 para o controlador SATA.&#x20;
- C(controller\_type), C(controller\_number) e C(unit\_number) são necessários ao criar ou reconfigurar VMs com vários tipos de controladores de disco e discos.&#x20;
- Ao criar uma nova VM, o primeiro disco configurado na lista C(disk) será "Hard Disk 1".        |

## Sub-options de nvdimn

| **Parâmetro** | **Tipo** | **Escolhas \| Valor&#x20;*****Padrão*** | **Comentários**                                                                                                                                                                                                                                                                                              |
| ------------- | -------- | --------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| state         |  string  | - ****present****
- absent              | * O valor válido é C(presente) ou C(ausente).
* Se definido como C(ausente), o dispositivo NVDIMM com C(rótulo) especificado será removido.                                                                                                                                                                  |
| size\_mb      | interger |                                         | Tamanho do dispositivo NVDIMM virtual em MB<br />                                                                                                                                                                                                                                                            |
| label         | string   | ******                                  | - O rótulo do dispositivo NVDIMM virtual a ser removido ou configurado, por exemplo, "NVDIMM 1".
- 'Este parâmetro é necessário quando C(estado) é definido como C(ausente) ou C(presente) para reconfigurar o tamanho do dispositivo NVDIMM. Ao adicionar um novo dispositivo, não defina C(rótulo).'<br /> |

## Sub-options de cdrom

| **Parâmetro**      | **Tipo** | **Escolhas \| Valor&#x20;*****Padrão*** | **Comentários**                                                                                                                                                                                                                                       |
| ------------------ | -------- | --------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| type               |  string  |                                         | - O tipo de CD-ROM, as opções válidas são C(nenhum), C(cliente) ou C(iso).
- Com C(none) o CD-ROM será desconectado mas presente.
- O valor padrão é C(cliente).                                                                                      |
| iso\_path          | interger |                                         | * O caminho do armazenamento de dados para o arquivo ISO a ser usado, na forma de C(\[datastore1] path/to/file.iso).
* Obrigatório se o tipo for definido como C(iso).<br /><br />                                                                    |
| controller\_type   | string   | ******                                  | - As opções válidas são C(ide) e C(sata).
-  O valor padrão é C(ide).
- Quando definido como C(sata), certifique-se de que C(unit\_number) esteja correto e não seja usado por discos SATA.<br />                                                     |
| controller\_number | interger |                                         | * Para o controlador C(ide), o valor válido é 0 ou 1.
* Para o controlador C(sata), o valor válido é de 0 a 3.                                                                                                                                        |
| unit\_number       | interger |                                         | - Para dispositivo de CD-ROM anexado ao controlador C(ide), o valor válido é 0 ou 1.
-  Para dispositivo de CD-ROM anexado ao controlador C(sata), o valor válido é de 0 a 29.
-  C(controller\_number) e C(unit\_number) são atributos obrigatórios. |
| state              | string   |                                         | * O valor válido é C(presente) ou C(ausente).
*  O padrão é C(presente).
* Se definido como C(ausente), o CD-ROM especificado será removido.                                                                                                          |

## Sub-options de networks

| **Parâmetro**    | **Tipo** | **Escolhas \| Valor&#x20;*****Padrão*** | **Comentários**                                                                                                                                                                                                                            |
| ---------------- | -------- | --------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| name             |  string  |                                         | - Nome do portgroup ou portgroup virtual distribuído para esta interface.
- Obrigatório por entrada.
- Ao especificar um grupo de portas virtual distribuído, certifique-se de que C(esxi\_hostname) ou C(cluster) esteja associado a ele. |
| vlan             | interger |                                         | * Número de VLAN para esta interface.
* Obrigatório por entrada.<br /><br />                                                                                                                                                               |
| device\_type     | string   | ******                                  | - Dispositivo de rede virtual.
- O valor válido pode ser C(e1000), C(e1000e), C(pcnet32), C(vmxnet2), C(vmxnet3), C(sriov).
- C(vmxnet3) é o padrão.
- Opcional por entrada.
- Usado para hardware virtual.<br />                          |
| mac              | string   |                                         | * Personalize o endereço MAC.
* Opcional por entrada.
* Usado para hardware virtual.                                                                                                                                                       |
| dvswitch         | string   |                                         | - Nome do vSwitch distribuído.
- Opcional por entrada.
- Usado para hardware virtual.                                                                                                                                                      |
| dvswitch\_name   | string   |                                         | * O valor válido é C(presente) ou C(ausente).
*  O padrão é C(presente).
* Se definido como C(ausente), o CD-ROM especificado será removido.                                                                                               |
| type             | string   |                                         | - Tipo de atribuição de IP.
- Os valores válidos são C(dhcp), C(estático).
- C(dhcp) é o padrão.
- Opcional por entrada.
- Usado para personalização do sistema operacional.                                                               |
| ip               | string   |                                         | * Endereço IP estático. Implica C(tipo=estático).
* Opcional por entrada.
* Usado para personalização do sistema operacional.                                                                                                              |
| netmask          | string   |                                         | - Máscara de rede estática necessária para C(ip).
- Opcional por entrada.
- Usado para personalização do sistema operacional.                                                                                                              |
| gateway          | string   |                                         | * Gateway estático.
* Opcional por entrada.
* Usado para personalização do sistema operacional.<br />                                                                                                                                      |
| dns\_servers     | string   |                                         | - Servidores DNS para esta interface de rede (Windows).
- Opcional por entrada.
- Usado para personalização do sistema operacional.                                                                                                        |
| domain           | string   |                                         | * Nome de domínio para esta interface de rede (Windows).
* Opcional por entrada.
* Usado para personalização do sistema operacional.                                                                                                       |
| connected        | bool     |                                         | - Indica se a NIC está conectada no momento.                                                                                                                                                                                               |
| start\_connected | bool     |                                         | * Especifica se deve ou não conectar o dispositivo quando a máquina virtual for iniciada.                                                                                                                                                  |

## Sub-options de customization

| **Parâmetro**       | **Tipo**    | **Escolhas \| Valor&#x20;*****Padrão*** | **Comentários**                                                                                                                                                                                                                                                                                   |
| ------------------- | ----------- | --------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| existing\_vm        | bool        |                                         | - Se definido como C(True), faça a personalização do sistema operacional na máquina virtual especificada diretamente.
-  Comum para personalização de Linux e Windows                                                                                                                             |
| dns\_servers        | list/string |                                         | * Lista de servidores DNS para configurar.
* Comum para personalização de Linux e Windows.<br /><br />                                                                                                                                                                                            |
| dns\_suffix         | list/string | ******                                  | - Lista de sufixos de domínio, também conhecida como caminho de pesquisa DNS.
- Parâmetro C(domínio) padrão.
- Comum para personalização de Linux e Windows.<br />                                                                                                                                |
| domain              | string      |                                         | * Nome de domínio DNS a ser usado.
* Comum para personalização de Linux e Windows.                                                                                                                                                                                                                |
| hostname            | string      |                                         | - Nome do host do computador.
- O padrão é o parâmetro C(nome) encurtado.
- Os caracteres permitidos são alfanuméricos (maiúsculas e minúsculas) e menos, o resto dos caracteres são descartados conforme RFC 952.
- Comum para personalização de Linux e Windows.                                |
| timezone            | string      |                                         | * Fuso horário.
* Consulte a lista de fusos horários suportados para diferentes versões do vSphere no Linux/Unix.
* Comum para personalização de Linux e Windows.
* L(Windows, [https://msdn.microsoft.com/en-us/library/ms912391.aspx](https://msdn.microsoft.com/en-us/library/ms912391.aspx)). |
| hwclockUTC          | bool        |                                         | - Especifica se o relógio do hardware está em UTC ou na hora local.
- Específico para personalização do Linux.                                                                                                                                                                                    |
| autologon           | bool        |                                         | * Logon automático após a personalização da máquina virtual.
* Específico para personalização do Windows.                                                                                                                                                                                         |
| autologonaccount    | interger    |                                         | - Número de logon automático após a reinicialização.
- Específico para personalização do Windows.
- Ignorado se C(autologon) não estiver definido ou definido como C(False).
- Se não definido, 1 será usado.<br />                                                                               |
| domainadmin         | string      |                                         | * Usuário usado para ingressar no domínio AD.
* Obrigatório se C(joindomain) for especificado.
* Específico para personalização do Windows.                                                                                                                                                       |
| domainadminpassword | string      |                                         | - Senha usada para entrar no domínio AD.
- Obrigatório se C(joindomain) for especificado.
- Específico para personalização do Windows.                                                                                                                                                            |
| fullname            | string      |                                         | * Server owner name.
* Specific to Windows customization.
* If unset, "Administrator" will be used as a fall-back.                                                                                                                                                                                |
| joindomain          | string      |                                         | - Domínio AD para ingressar.
- Não compatível com C(joinworkgroup).
- Específico para personalização do Windows.                                                                                                                                                                                  |
| joinworkgroup       | string      |                                         | * Grupo de trabalho para participar.
* Não compatível com C(joindomain).
* Específico para personalização do Windows.
* Se não for definido, "WORKGROUP" será usado como substituto.                                                                                                              |
| orgname             | string      |                                         | - Nome da organização.
- Específico para personalização do Windows.
- Se não for definido, "ACME" será usado como substituto.                                                                                                                                                                     |
| password            | string      |                                         | * Senha do administrador local.
* Específico para personalização do Windows.                                                                                                                                                                                                                      |
| productid           | string      |                                         | - ID do produto.
- Específico para personalização do Windows.                                                                                                                                                                                                                                     |
| runonce             | list/string |                                         | * Lista de comandos a serem executados no primeiro logon do usuário.
* Específico para personalização do Windows.                                                                                                                                                                                 |

## Sub-options de vaap\_properties

| **Parâmetro** | **Tipo** | **Escolhas \| Valor&#x20;*****Padrão*** | **Comentários**                                                     |
| ------------- | -------- | --------------------------------------- | ------------------------------------------------------------------- |
| id            |  string  |                                         | - ID da propriedade.
- Obrigatório por entrada.                     |
| value         | string   |                                         | * Valor da propriedade<br /><br />                                  |
| type          | string   | ******                                  | - Tipo de valor, tipo de string por padrão.<br />                   |
| operation     | string   |                                         | * O atributo C(remove) é necessário apenas ao remover propriedades. |

## Notas

Observação

- Testado em vSphere 7.0.2
- Todos os módulos requerem acesso de gravação API e, portanto, não são suportados em uma licença ESXi gratuita.
- Por exemplo, a seguir está a lista de privilégios mínimos exigidos pelos usuários para criar máquinas virtuais.
- DataStore > Alocar Espaço
- Virtual Machine > Configuration > Add New Disk
- Virtual Machine > Configuration > Add or Remove Device
- Virtual Machine > Inventory > Create New
- Network > Assign Network
- Resource > Assign Virtual Machine to Resource Pool



## Exemplos

```yaml
- name: Create a virtual machine on given ESXi hostname
  vmware_guest:
    hostname: "{{ vcenter_hostname }}"
    username: "{{ vcenter_username }}"
    password: "{{ vcenter_password }}"
    folder: /DC1/vm/
    name: test_vm_0001
    state: poweredon
    guest_id: centos64Guest
    # This is hostname of particular ESXi server on which user wants VM to be deployed
    esxi_hostname: "{{ esxi_hostname }}"
    disk:
    - size_gb: 10
      type: thin
      datastore: datastore1
    hardware:
      memory_mb: 512
      num_cpus: 4
      scsi: paravirtual
    networks:
    - name: VM Network
      mac: aa:bb:dd:aa:00:14
      ip: 10.10.10.100
      netmask: 255.255.255.0
      device_type: vmxnet3
    wait_for_ip_address: true
    wait_for_ip_address_timeout: 600
  delegate_to: localhost
  register: deploy_vm

- name: Create a virtual machine from a template
  vmware_guest:
    hostname: "{{ vcenter_hostname }}"
    username: "{{ vcenter_username }}"
    password: "{{ vcenter_password }}"
    folder: /testvms
    name: testvm_2
    state: poweredon
    template: template_el7
    disk:
    - size_gb: 10
      type: thin
      datastore: g73_datastore
    # Add another disk from an existing VMDK
    - filename: "[datastore1] testvms/testvm_2_1/testvm_2_1.vmdk"
    hardware:
      memory_mb: 512
      num_cpus: 6
      num_cpu_cores_per_socket: 3
      scsi: paravirtual
      memory_reservation_lock: True
      mem_limit: 8096
      mem_reservation: 4096
      cpu_limit: 8096
      cpu_reservation: 4096
      max_connections: 5
      hotadd_cpu: True
      hotremove_cpu: True
      hotadd_memory: False
      version: 12 # Hardware version of virtual machine
      boot_firmware: "efi"
    cdrom:
        - controller_number: 0
          unit_number: 0
          state: present
          type: iso
          iso_path: "[datastore1] livecd.iso"
    networks:
    - name: VM Network
      mac: aa:bb:dd:aa:00:14
    wait_for_ip_address: true
  delegate_to: localhost
  register: deploy

- name: Clone a virtual machine from Windows template and customize
  vmware_guest:
    hostname: "{{ vcenter_hostname }}"
    username: "{{ vcenter_username }}"
    password: "{{ vcenter_password }}"
    datacenter: datacenter1
    cluster: cluster
    name: testvm-2
    template: template_windows
    networks:
    - name: VM Network
      ip: 192.168.1.100
      netmask: 255.255.255.0
      gateway: 192.168.1.1
      mac: aa:bb:dd:aa:00:14
      domain: my_domain
      dns_servers:
      - 192.168.1.1
      - 192.168.1.2
    - vlan: 1234
      type: dhcp
    customization:
      autologon: true
      dns_servers:
      - 192.168.1.1
      - 192.168.1.2
      domain: my_domain
      password: new_vm_password
      runonce:
      - powershell.exe -ExecutionPolicy Unrestricted -File C:\Windows\Temp\ConfigureRemotingForAtmosphere.ps1 -ForceNewSSLCert -EnableCredSSP
  delegate_to: localhost

- name:  Clone a virtual machine from Linux template and customize
  vmware_guest:
    hostname: "{{ vcenter_hostname }}"
    username: "{{ vcenter_username }}"
    password: "{{ vcenter_password }}"
    datacenter: "{{ datacenter }}"
    state: present
    folder: /DC1/vm
    template: "{{ template }}"
    name: "{{ vm_name }}"
    cluster: DC1_C1
    networks:
      - name: VM Network
        ip: 192.168.10.11
        netmask: 255.255.255.0
    wait_for_ip_address: True
    customization:
      domain: "{{ guest_domain }}"
      dns_servers:
        - 8.9.9.9
        - 7.8.8.9
      dns_suffix:
        - example.com
        - example2.com
  delegate_to: localhost

- name: Rename a virtual machine (requires the virtual machine's uuid)
  vmware_guest:
    hostname: "{{ vcenter_hostname }}"
    username: "{{ vcenter_username }}"
    password: "{{ vcenter_password }}"
    uuid: "{{ vm_uuid }}"
    name: new_name
    state: present
  delegate_to: localhost

- name: Remove a virtual machine by uuid
  vmware_guest:
    hostname: "{{ vcenter_hostname }}"
    username: "{{ vcenter_username }}"
    password: "{{ vcenter_password }}"
    uuid: "{{ vm_uuid }}"
    state: absent
  delegate_to: localhost

- name: Remove a virtual machine from inventory
  vmware_guest:
    hostname: "{{ vcenter_hostname }}"
    username: "{{ vcenter_username }}"
    password: "{{ vcenter_password }}"
    name: vm_name
    delete_from_inventory: True
    state: absent
  delegate_to: localhost

- name: Manipulate vApp properties
  vmware_guest:
    hostname: "{{ vcenter_hostname }}"
    username: "{{ vcenter_username }}"
    password: "{{ vcenter_password }}"
    name: vm_name
    state: present
    vapp_properties:
      - id: remoteIP
        category: Backup
        label: Backup server IP
        type: string
        value: 10.10.10.1
      - id: old_property
        operation: remove
  delegate_to: localhost

- name: Set powerstate of a virtual machine to poweroff by using UUID
  vmware_guest:
    hostname: "{{ vcenter_hostname }}"
    username: "{{ vcenter_username }}"
    password: "{{ vcenter_password }}"
    uuid: "{{ vm_uuid }}"
    state: poweredoff
  delegate_to: localhost

- name: Deploy a virtual machine in a datastore different from the datastore of the template
  vmware_guest:
    hostname: "{{ vcenter_hostname }}"
    username: "{{ vcenter_username }}"
    password: "{{ vcenter_password }}"
    name: "{{ vm_name }}"
    state: present
    template: "{{ template_name }}"
    # Here datastore can be different which holds template
    datastore: "{{ virtual_machine_datastore }}"
    hardware:
      memory_mb: 512
      num_cpus: 2
      scsi: paravirtual
  delegate_to: localhost

- name: Create a diskless VM
  vmware_guest:
    hostname: "{{ vcenter_hostname }}"
    username: "{{ vcenter_username }}"
    password: "{{ vcenter_password }}"
    datacenter: "{{ dc1 }}"
    state: poweredoff
    cluster: "{{ ccr1 }}"
    name: diskless_vm
    folder: /Asia-Datacenter1/vm
    guest_id: centos64Guest
    datastore: "{{ ds1 }}"
    hardware:
        memory_mb: 1024
        num_cpus: 2
        num_cpu_cores_per_socket: 1

- name: Create a VM with multiple disks of different disk controller types
  vmware_guest:
    hostname: "{{ vcenter_hostname }}"
    username: "{{ vcenter_username }}"
    password: "{{ vcenter_password }}"
    folder: /DC1/vm/
    name: test_vm_multi_disks
    state: poweredoff
    guest_id: centos64Guest
    datastore: datastore1
    disk:
    - size_gb: 10
      controller_type: 'nvme'
      controller_number: 0
      unit_number: 0
    - size_gb: 10
      controller_type: 'paravirtual'
      controller_number: 0
      unit_number: 1
    - size_gb: 10
      controller_type: 'sata'
      controller_number: 0
      unit_number: 2
    hardware:
      memory_mb: 512
      num_cpus: 4
      version: 14
    networks:
    - name: VM Network
      device_type: vmxnet3
  delegate_to: localhost
  register: deploy_vm

- name: Create a VM with NVDIMM device
  vmware_guest:
    hostname: "{{ vcenter_hostname }}"
    username: "{{ vcenter_username }}"
    password: "{{ vcenter_password }}"
    folder: /DC1/vm/
    name: test_vm_nvdimm
    state: poweredoff
    guest_id: centos7_64Guest
    datastore: datastore1
    hardware:
      memory_mb: 512
      num_cpus: 4
      version: 14
    networks:
    - name: VM Network
      device_type: vmxnet3
    nvdimm:
      state: present
      size_mb: 2048
  delegate_to: localhost
  register: deploy_vm
  
```

## Valores Retornados

| **Chave** | **Tipo**   | **Retornado quando** | **Descrição**                     |
| --------- | ---------- | -------------------- | --------------------------------- |
| instance  | dictionary | sempre               | metadados sobre a máquina virtual |

