Esta página foi traduzida pela API Cloud Translation.

Tutorial: crie e faça a gestão de uma VM do Linux no tempo de execução de VMs no GDC

Este tutorial mostra como criar e gerir uma máquina virtual (VM) do Linux numa nova instalação do VM Runtime no GDC. Aprende o processo para criar e definir as dependências básicas, como um StorageClass e uma rede virtual, e, em seguida, criar uma VM que use estes recursos. Em seguida, aprende a editar a VM, por exemplo, para adicionar um novo disco.

Crie um `StorageClass`

Usa um StorageClass para definir o tipo de armazenamento que disponibiliza às VMs. As diferentes classes de armazenamento podem ser mapeadas para um tipo diferente de hardware de armazenamento, sistema de ficheiros ou desempenho.

Está fora do âmbito deste tutorial fornecer instruções específicas para cada StorageClass e parceiro de armazenamento.

Os parceiros de armazenamento do Google Distributed Cloud Ready fornecem controladores Container Storage Interface (CSI) qualificados que instalam e configuram os recursos personalizados necessários para o seu armazenamento. Para instalar o controlador CSI no cluster, reveja a lista de parceiros de armazenamento suportados e siga as respetivas instruções.

Depois de instalar o controlador CSI para a sua plataforma de armazenamento, uma ou mais classes de armazenamento estão disponíveis no seu cluster. Vai usar uma destas classes de armazenamento para criar um disco rígido virtual neste tutorial.

O exemplo básico seguinte NFS StorageClass usa o NFS CSI Driver. Define o endereço do servidor NFS e o caminho a usar no StorageClass. Todos os nós no cluster podem, em seguida, ligar-se e usar este armazenamento NFS:

  apiVersion: storage.k8s.io/v1
  kind: StorageClass
  metadata:
    name: example-nfs
  provisioner: nfs.csi.k8s.io
  parameters:
    server: nfs-server.example.com
    path: /vm-share
  reclaimPolicy: Delete
  volumeBindingMode: Immediate
  mountOptions:
    - nconnect=8
    - nfsvers=4.1

Neste tutorial, use o nome de um StorageClass no seu próprio cluster.

O VM Runtime no GDC gera automaticamente um perfil de armazenamento para cada StorageClass num cluster. O perfil de armazenamento tem o mesmo nome que o StorageClass associado. Os perfis de armazenamento oferecem opções de configuração adicionais associadas a cada StorageClass. Para mais informações sobre os perfis de armazenamento, incluindo instruções de configuração, consulte o artigo Configure perfis de armazenamento.

Crie uma rede virtual

As VMs estabelecem ligação a uma rede virtual através de uma interface de rede virtual. A rede virtual permite-lhes comunicar com outras VMs no cluster ou com recursos fora do cluster.

Neste tutorial, vai criar uma rede virtual básica da camada 2 (L2) que pode usar um servidor DHCP externo. Quando ativa a utilização de um servidor DHCP externo, pode ignorar a configuração das definições de DNS e gateway se forem fornecidas pelo DHCP.

Para criar uma rede que use um servidor DHCP externo, conclua os seguintes passos:

Crie um manifesto Network, como dhcp-network.yaml, no editor da sua escolha:
```
nano dhcp-network.yaml
```
Copie e cole o seguinte manifesto YAML:
```
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: NETWORK_NAME
spec:
  type: L2
  nodeInterfaceMatcher:
    interfaceName: INTERFACE_NAME
  externalDHCP4: true
```
Substitua os seguintes valores:
- NETWORK_NAME: o nome da sua rede.
- INTERFACE_NAME: o nome da interface no seu nó do Google Distributed Cloud ao qual anexar a rede. Todos os nós devem ter o mesmo nome de interface.
Neste manifesto Network, são definidos os seguintes valores:
- As cargas de trabalho só podem ter um anexo L2 a esta rede. Esta é a única rede type que pode criar no tempo de execução da VM no GDC.
- A rede tem o DHCP externo ativado. O servidor DHCP externo é responsável pela atribuição de endereços IPv4, rotas, gateway e configuração de DNS para cargas de trabalho ligadas a esta rede.
Guarde e feche o manifesto Network no editor.
Crie a rede com kubectl:
```
kubectl apply -f use-dhcp-network.yaml
```

Crie um disco de arranque de VM

Uma VM pode usar uma imagem de disco pré-criada ou arrancar a partir de uma imagem ISO para instalar manualmente o SO. Estas imagens de disco podem ser armazenadas e acedidas através de HTTP ou no Cloud Storage e acedidas através de um Secret.

Neste tutorial, cria um disco de arranque a partir da imagem de nuvem pública do Ubuntu Server 20.04 através de HTTP.

Para criar um disco a partir de uma imagem, conclua os passos seguintes.

Crie um manifesto VirtualMachineDisk, como my-disk.yaml, no editor à sua escolha:
```
nano my-disk.yaml
```
Copie e cole a seguinte definição YAML:
```
apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineDisk
metadata:
  name: DISK_NAME
spec:
  size: 20Gi
  storageClassName: STORAGE_CLASS_NAME
  source:
    http:
      url: https://cloud-images.ubuntu.com/releases/focal/release/ubuntu-20.04-server-cloudimg-amd64.img
```
Substitua os seguintes valores:
- DISK_NAME: o nome que quer para o disco. Este exemplo cria um disco de 20Gi20 gibibytesDISK_NAME denominado DISK_NAMEusando uma imagem pública do Ubuntu Server 20.04.
- STORAGE_CLASS_NAME: o StorageClass que quer usar para o seu VirtualMachineDisk.
  - Use kubectl get storageclass para listar o que está disponível no seu cluster.
Nota: pode demorar 15 a 20 minutos a transferir esta imagem pública, criar a VirtualMachineDisk e aplicar a imagem do SO ao novo disco. O processo de criação do VirtualMachineDisk é muito mais rápido quando usa uma imagem armazenada localmente. Na maioria dos cenários de produção, use um repositório de imagens HTTP local em vez de extrair de uma fonte pública externa de cada vez.
Guarde e feche o manifesto VirtualMachineDisk no editor.
Crie o disco com kubectl:
```
kubectl apply -f my-disk.yaml
```

Crie uma VM

Com uma rede virtual e um disco de arranque criados nas secções anteriores, crie agora uma VM. A VM liga-se à rede virtual e arranca a partir do disco virtual. As instruções seguintes criam uma VM aplicando diretamente um ficheiro de manifesto YAML com a CLI kubectl.VirtualMachine

Crie um manifesto que defina um VirtualMachine, como my-vm.yaml, no editor à sua escolha:
```
nano my-vm.yaml
```
Copie e cole a seguinte definição YAML:
```
apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachine
metadata:
  name: VM_NAME
spec:
  osType: linux
  compute:
    cpu:
      vcpus: VCPU_NUMBER
    memory:
      capacity: MEMORY_SIZE
  interfaces:
    - name: eth0
      networkName: NETWORK_NAME
      default: true
  disks:
    - boot: true
      virtualMachineDiskName: DISK_NAME
```
Substitua os seguintes valores:
- VM_NAME: o nome da sua VM.
- VCPU_NUMBER: O número opcional de vCPUs a atribuir à VM. Sem esta definição, é atribuída a predefinição de 2 vCPUs.
  - Pode atribuir entre 1 e 96 vCPUs a uma VM.
- MEMORY_SIZE: A quantidade opcional de memória a atribuir à VM. Sem esta definição, é atribuída a predefinição de 4 GiB de memória.
  - Pode atribuir entre 1 MB e 1 TB de memória a uma VM. Para mais informações, consulte Unidades de recursos de memória.
- NETWORK_NAME: o nome da sua rede criado numa secção anterior.
- DISK_NAME: o nome do disco de arranque criado na secção anterior. Este disco está definido como boot: true.
Guarde e feche o manifesto no editor.
Crie a VM e o disco com kubectl:
```
kubectl apply -f my-vm.yaml
```
A criação da VM pode demorar alguns minutos. Verifique o estado da VM com o comando kubectl:
```
kubectl get gvm VM_NAME
```
O exemplo de saída seguinte mostra a VM num estado Running:
```
NAME    STATUS    AGE   IP
MY_VM   Running   64s   192.168.2.124
```

Estabeleça ligação à VM

Quando a VM estiver em execução, ligue-se à consola da VM. Esta ligação à consola permite-lhe realizar tarefas básicas, como configurar ainda mais a VM ou instalar uma aplicação.

Para aceder a uma VM a partir da consola, use kubectl:
```
kubectl virt console VM_NAME
```
Quando lhe for pedido, introduza as credenciais do utilizador que especificou para criar a VM.
Depois de se ligar com êxito à consola da VM, saia da sessão da VM e da consola:
```
Ctrl + ]
```

Edite a VM

Durante o ciclo de vida da VM, pode querer editá-la. Por exemplo, pode querer adicionar armazenamento para instalar uma aplicação num disco dedicado ou usar armazenamento adicional para a sua aplicação.

Neste tutorial, crie um disco em branco e anexe-o à VM. Este cenário permite-lhe criar um disco de dados para armazenar dados de aplicações.

Crie um manifesto VirtualMachineDisk, como my-data-disk.yaml, no editor à sua escolha:
```
nano my-data-disk.yaml
```
Copie e cole a seguinte definição YAML:
```
apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineDisk
metadata:
  name: DATA_DISK_NAME
spec:
  size: 10Gi
  storageClassName: STORAGE_CLASS_NAME
```
Substitua os seguintes valores:
- DATA_DISK_NAME: o nome que quer dar ao disco de dados. Este exemplo cria um disco de 10Gi (10 gibibytes).
- STORAGE_CLASS_NAME: o StorageClass que quer usar para o seu VirtualMachineDisk.
  - Use kubectl get storageclass para listar o que está disponível no seu cluster.
Guarde e feche o manifesto do disco no editor.
Crie o disco com kubectl:
```
kubectl apply -f my-data-disk.yaml
```
Use kubectl para parar a VM antes de anexar o novo disco virtual:
```
kubectl virt stop VM_NAME
```

Edite o recurso de VM:

kubectl edit gvm VM_NAME

Atualize o manifesto YAML para anexar o disco no final da secção spec.disks da VM:VirtualMachine

apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachine
metadata:
  name: VM_NAME
spec:
  ...
  disks:
    - boot: true
      virtualMachineDiskName: DISK_NAME
    - virtualMachineDiskName: DATA_DISK_NAME

Substitua DATA_DISK_NAME pelo nome do disco criado no passo anterior.

Guarde e feche o manifesto de VMs atualizado no editor.
Use kubectl para iniciar a VM:
```
kubectl virt start VM_NAME
```