Implantando uma VM autônoma em vSphere with Tanzu

Como engenheiro de DevOps, você pode analisar os recursos de VM disponíveis e provisionar uma VM autônoma em um namespace em um Supervisor. Use o comando kubectl para executar as seguintes tarefas.

Pré-requisitos

Para poder implantar uma VM autônoma em vSphere with Tanzu, um engenheiro de DevOps deve ter acesso a recursos de VM específicos. Certifique-se de que um administrador do vSphere tenha realizado estas etapas para disponibilizar os recursos da VM:

Crie um namespace e atribua políticas de armazenamento a ele. Consulte Criar e configurar um namespace vSphere no Instalando e configurando o vSphere with Tanzu.
Crie uma biblioteca de conteúdo e associe-a ao namespace. Consulte Criando e gerenciando bibliotecas de conteúdo para VMs autônomas em vSphere with Tanzu.
- Se uma biblioteca de conteúdo estiver protegida por uma política de segurança, todos os itens da biblioteca deverão ser reclamados. Se a biblioteca protegida incluir uma combinação de itens compatíveis e não compatíveis, o comando kubectl get virtualmachineimages falhará ao apresentar imagens de VM para os engenheiros de DevOps.
- Se você planeja implantar VMs com dispositivos vGPU, deve ter acesso a imagens com o modo de inicialização definido como EFI, como CentOS.
Associe classes de VM padrão ou personalizadas a um namespace. Consulte Trabalhando com classes de VM em vSphere with Tanzu.
Se você planeja usar a NVIDIA vGPU ou outros dispositivos PCI para suas VMs, a classe VM deve incluir a configuração PCI. Consulte Adicionar dispositivos PCI a uma classe de VM em vSphere with Tanzu.

Exibir recursos de VM disponíveis em um namespace em vSphere with Tanzu

Como engenheiro de DevOps, verifique se você pode acessar os recursos de VM em seu namespace e visualizar as classes de VM e os modelos de VM disponíveis em seu ambiente. Você também pode listar classes de armazenamento e outros itens que podem ser necessários para o autoatendimento de uma VM.

Esta tarefa abrange os comandos que você usa para acessar os recursos disponíveis para uma implantação de uma VM autônoma. Para obter informações sobre os recursos necessários para implantar Tanzu Kubernetes Grid clusters e VMs que compõem os clusters, consulte Classes de máquina virtual para clusters TKG na documentação Usando Tanzu Kubernetes Grid 2 com vSphere with Tanzu.

Procedimento

Acesse seu namespace no ambiente Kubernetes.
Consulte Obter e usar o contexto Supervisor.
Para exibir as classes de VM disponíveis em seu namespace, execute o seguinte comando.
kubectl get virtualmachineclassbindings
Você pode ver a seguinte saída.

Observação: Como o tipo de classe de VM de melhor esforço permite que os recursos sejam supercomprometidos, você poderá ficar sem recursos se tiver definido limites no namespace no qual está provisionando as VMs. Por esse motivo, use o tipo de classe de VM garantido no ambiente de produção.
```
NAME                       VIRTUALMACHINECLASS        AGE

best-effort-large          best-effort-large          44m
best-effort-medium         best-effort-medium         44m
best-effort-small          best-effort-small          44m
best-effort-xsmall         best-effort-xsmall         44m
custom                     custom                     44m
```
Para exibir os detalhes de uma classe de VM específica, execute os comandos a seguir.
- kubectl describe virtualmachineclasses name_vm_class
  Se uma classe de VM incluir um dispositivo vGPU, você poderá ver seu perfil em spec: hardware: devices: vgpuDevices.
```
......
spec:
  hardware:
    cpus: 4
    devices:
      vgpuDevices:
      - profileName: grid_v100-q4
......
```
- kubectl get virtualmachineclasses -o wide
  Se a classe de VM incluir uma vGPU ou um dispositivo de passagem, a saída a mostrará na coluna VGPUDevicesProfileNames ou PassthroughDeviceIDs.

Visualize as imagens da VM.

kubectl get virtualmachineimages

A saída que você vê é semelhante à seguinte.

NAME                                              VERSION  OSTYPE                FORMAT  IMAGESUPPORTED  AGE
centos-stream-8-vmservice-v1alpha1-xxxxxxxxxxxxx           centos8_64Guest       ovf     true            4d3h

Para descrever uma imagem específica, use o seguinte comando.
kubectl describe virtualmachineimage/centos-stream-8-vmservice-v1alpha1-xxxxxxxxxxxxx
As VMs com dispositivos vGPU exigem imagens com o modo de inicialização definido como EFI, como o CentOS. Certifique-se de ter acesso a essas imagens.

Verifique se você pode acessar as classes de armazenamento.

kubectl get resourcequotas

Para obter mais informações, consulte Exibir classes de armazenamento em um vSphere Namespace.

NAME                        AGE   REQUEST                                                                                         LIMIT
my-ns-ubuntu-storagequota   24h   wcpglobal-storage-profile.storageclass.storage.k8s.io/requests.storage: 0/9223372036854775807

Se você estiver usando vSphere Distributed Switch para sua rede de carga de trabalho, obtenha o nome da rede.

Observação: Use essas informações para especificar o parâmetro networkName no arquivo YAML da VM quando o networkType for distribuído pelo vsphere. Você não precisa obter e especificar o nome da rede se usar VMware NSX.

kubectl get network
```
NAME      AGE
primary   7d2h
```

Implantar uma máquina virtual em vSphere with Tanzu

Como engenheiro de DevOps, provisione uma VM e seu sistema operacional convidado de maneira declarativa escrevendo especificações de implantação de VM em um arquivo YAML do Kubernetes.

Pré-requisitos

Se você usar NVIDIA vGPU ou outros dispositivos PCI para suas VMs, as seguintes considerações se aplicam:

Certifique-se de usar a classe de VM apropriada com a configuração PCI. Consulte Adicionar dispositivos PCI a uma classe de VM em vSphere with Tanzu.
As VMs com dispositivos vGPU exigem imagens com o modo de inicialização definido como EFI, como o CentOS.
As VMs com dispositivos vGPU gerenciados pelo Serviço de VM são automaticamente desligadas quando um host ESXi entra no modo de manutenção. Isso pode afetar temporariamente as cargas de trabalho em execução nas VMs. As VMs são ligadas automaticamente depois que o host entra no modo de manutenção.

Procedimento

Prepare o arquivo YAML da VM.

No arquivo, especifique os seguintes parâmetros:

Opção	Descrição
apiVersion	Especifica a versão da API do Serviço de VM. Como `vmoperator.vmware.com/v1alpha1`.
amável	Especifica o tipo de recurso do Kubernetes a ser criado. O único valor disponível é `VirtualMachine`.
spec.imageName	Especifica a imagem da biblioteca de conteúdo que a VM deve usar.
spec.storageClass	Identifica a classe de armazenamento a ser usada para armazenamento dos volumes persistentes.
spec.className	Especifica o nome da classe de VM que descreve as configurações de hardware virtual a serem usadas.
spec.networkInterfaces	Especifica as configurações relacionadas à rede para a VM. networkType. Os valores para essa chave podem ser `nsx-t` ou `vsphere-distributed`. networkName. Especifique o nome somente se networkType for `distribuído pelo vsphere`. Você pode obter essas informações usando o comando kubectl get network. Se networkType for `nsx-t`, você não precisará indicar networkName.
spec.vmMetadata	Inclui metadados adicionais a serem passados para a VM. Você pode usar essa chave para personalizar a imagem do SO convidado e definir itens como o hostname da VM e o user-data, incluindo senhas, chaves ssh e assim por diante. O exemplo de YAML abaixo usa ConfigMap para armazenar os metadados.
topology.kubernetes.io/zone	Controla o posicionamento da VM em um Supervisor de três zonas. Por exemplo, topology.kubernetes.io/zone: zone-a02.

Use o seguinte como um exemplo de um arquivo YAML ubuntu-impish-vm.yaml.

apiVersion: vmoperator.vmware.com/v1alpha1
kind: VirtualMachine
metadata:
  name: ubuntu-impish-vm
  namespace: sr-1
  annotations:
    vmoperator.vmware.com/image-supported-check: disable
spec:
  networkInterfaces:
  - networkName: ""
    networkType: nsx-t
  className: best-effort-medium
  imageName: ubuntu-impish-21.10-cloudimg 
  powerState: poweredOn
  storageClass: vsan-default-storage-policy
  vmMetadata:
    configMapName: user-data-2
    transport: CloudInit
---
apiVersion: v1
kind: ConfigMap
metadata:
    name: user-data-2
    namespace: sr-1
data:
  user-data: |
    #cloud-config
    ssh_pwauth: true
    users:
      - name: vmware
        sudo: ALL=(ALL) NOPASSWD:ALL
        lock_passwd: false
        passwd: '$1$salt$SOC33fVbA/ZxeIwD5yw1u1'
        shell: /bin/bash
    write_files:
      - content: |
          VMSVC Says Hello World
        path: /helloworld

ConfigMap contém o blob cloud-config que especifica o nome de usuário e a senha do sistema operacional convidado.

Para obter mais informações sobre as especificações do cloud-config, consulte https://cloudinit.readthedocs.io/en/latest/topics/examples.html.

Implante a VM.
```
kubectl apply -f ubuntu-impish-vm.yaml
```

Verifique se a VM foi criada.

kubectl get vm -n ubuntu-impish-vm
NAME              AGE
ubuntu-impish-vm  28s

Verifique o status da VM e os eventos associados.

kubectl describe virtualmachine ubuntu-impish-vm

A saída é semelhante à seguinte. Na saída, você também pode obter o endereço IP da VM, que aparece no campo Vm Ip.

Name:         ubuntu-impish-vm
Namespace:    sr-1
Annotations:  vmoperator.vmware.com/image-supported-check: disabled
API Version:  vmoperator.vmware.com/v1alpha1
Kind:         VirtualMachine
Metadata:
  Creation Timestamp:  2021-03-23T19:07:36Z
  Finalizers:
    virtualmachine.vmoperator.vmware.com
  Generation:  1
  Managed Fields:
 ...  
 ... 
Spec:
  Class Name:  best-effort-medium
  Image Name:  ubuntu-impish-21.10-cloudimg
  Network Interfaces:
    Network Name:  ""
    Network Type:  nsx-t
  Power State:     poweredOn
  Storage Class:   vsan-default-storage-policy
  Vm Metadata:
    Config Map Name:  user-data-2
    Transport:        CloudInit
Status:
  Bios UUID:              4218ec42-aeb3-9491-fe22-19b6f954ce38
  Change Block Tracking:  false
  Conditions:
    Last Transition Time:  2021-03-23T19:08:59Z
    Status:                True
    Type:                  VirtualMachinePrereqReady
  Host:                    10.185.240.10
  Instance UUID:           50180b3a-86ee-870a-c3da-90ddbaffc950
  Phase:                   Created
  Power State:             poweredOn
  Unique ID:               vm-73
  Vm Ip:                   10.161.75.162
Events:                    <none>
...

Verifique se o IP da VM está acessível.

ping 10.161.75.162
PING 10.161.75.162 (10.161.75.162): 56 data bytes
64 bytes from 10.161.75.162: icmp_seq=0 ttl=59 time=43.528 ms
64 bytes from 10.161.75.162: icmp_seq=1 ttl=59 time=53.885 ms
64 bytes from 10.161.75.162: icmp_seq=2 ttl=59 time=31.581 ms

Resultados

Uma VM criada por meio do Serviço de VM pode ser gerenciada somente pelo DevOps do namespace Kubernetes. Seu ciclo de vida não pode ser gerenciado a partir do vSphere Client, mas os administradores do vSphere podem monitorar a VM e seus recursos. Para obter mais informações, consulte Monitorar máquinas virtuais disponíveis em vSphere with Tanzu.

O que Fazer Depois

Para obter detalhes adicionais, consulte o blog Introdução ao provisionamento de máquina virtual.

Instalar o driver convidado NVIDIA em uma VM em vSphere with Tanzu

Se a VM incluir um dispositivo PCI configurado para vGPU, depois de criar e inicializar a VM no ambiente vSphere with Tanzu, instale o driver gráfico NVIDIA vGPU para habilitar totalmente as operações de GPU.

Pré-requisitos

Certifique-se de que a VM que você criou faça referência à classe de VM com a definição de vGPU. Consulte Adicionar dispositivos PCI a uma classe de VM em vSphere with Tanzu.
Verifique se você baixou o pacote de software da vGPU do site de download da NVIDIA, descompactou o pacote e se o componente da unidade convidada está pronto. Para obter informações, consulte a documentação apropriada do software NVIDIA Virtual GPU.
Observação: A versão do componente do driver deve corresponder à versão do vGPU Manager que um administrador vSphere instalou no host ESXi.

Procedimento

Copie o pacote de driver Linux do software NVIDIA vGPU, por exemplo, NVIDIA-Linux-x86_64-version-grid.run, para a VM convidada.
Antes de tentar executar o instalador do driver, encerre todos os aplicativos.

Inicie o instalador do driver NVIDIA vGPU.

sudo ./NVIDIA-Linux-x86_64-version-grid.run

Aceite o contrato de licença do software NVIDIA e selecione Sim (Yes) para atualizar as definições de configuração do X automaticamente.

Verifique se o driver foi instalado.

Por exemplo,

~$ nvidia-smi
Wed May 19 22:15:04 2021
+-----------------------------------------------------------------------------+
| NVIDIA-SMI 460.63       Driver Version: 460.63       CUDA Version: 11.2     |
|-------------------------------+----------------------+----------------------+
| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |
| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |
|                               |                      |               MIG M. |
|===============================+======================+======================|
|   0  GRID V100-4Q        On   | 00000000:02:00.0 Off |                  N/A|
| N/AN/AP0    N/A/  N/A|    304MiB /  4096MiB |      0%      Default |
|                               |                      |                  N/A|
+-------------------------------+----------------------+----------------------+

+-----------------------------------------------------------------------------+
| Processes:                                                                  |
|  GPU   GI   CI        PID   Type   Process name                  GPU Memory |
|        ID   ID                                                   Usage      |
|=============================================================================|
|  No running processes found                                                 |
+-----------------------------------------------------------------------------+