Neste tutorial, mostramos como criar e gerenciar uma máquina virtual (VM) do Linux
em uma nova instalação do ambiente de execução de VM no GDC. Você aprenderá o processo para criar e definir as dependências básicas, como StorageClass
e rede virtual, e depois criar uma VM que usa esses recursos. Em seguida, você aprenderá a editar a VM, por exemplo, para adicionar um novo disco.
Objetivos
- Configurar dependências básicas
- Crie um
StorageClass
para o ambiente de execução da VM no GDC - Criar uma rede virtual para ser usada pelas VMs
- Crie um
- Criar um disco de inicialização de máquina virtual
- Criar uma VM
- Editar uma VM para adicionar um novo disco virtual
Antes de começar
Para concluir este tutorial, você precisa de acesso aos recursos e ferramentas a seguir:
- Acesso ao cluster do Google Distributed Cloud versão 1.12.0 (
anthosBareMetalVersion: 1.12.0
) ou superior. Use qualquer tipo de cluster capaz de executar cargas de trabalho. Se necessário, teste o Google Distributed Cloud no Compute Engine ou consulte a visão geral de criação de clusters. - A ferramenta do cliente
virtctl
instalada como um plug-in para okubectl
. Se necessário, instale a ferramenta de cliente virtctl.
Criar um StorageClass
Use um StorageClass
para definir o tipo de armazenamento que disponibiliza para as VMs. Diferentes classes de armazenamento podem ser mapeadas para um tipo diferente de hardware
de armazenamento, sistema de arquivos ou desempenho.
Está fora do escopo deste tutorial fornecer instruções específicas para cada StorageClass
e parceiro de armazenamento.
Os parceiros de armazenamento do Google Distributed Cloud Ready fornecem drivers Container Storage Interface (CSI, na sigla em inglês) qualificados que instalam e configuram os recursos personalizados necessários para o armazenamento. Para instalar o driver CSI no cluster, consulte a lista de parceiros de armazenamento compatíveis e siga as instruções.
Depois de instalar o driver CSI na plataforma de armazenamento, uma ou mais classes de armazenamento ficam disponíveis no cluster. Neste tutorial, use uma dessas classes de armazenamento para criar um disco rígido virtual.
O exemplo básico a seguir
StorageClass
do NFS
usa o
driver CSI do NFS.
Você define o endereço do servidor NFS e o caminho a ser usado no StorageClass
. Todos os nós do cluster podem se conectar 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 ambiente de execução da VM no GDC gera automaticamente um perfil de armazenamento para
cada StorageClass
em um cluster. O perfil de armazenamento tem o mesmo nome do
StorageClass
associado. Os perfis de armazenamento oferecem opções de configuração adicionais associadas a cada StorageClass
. Para mais informações sobre perfis de
armazenamento, incluindo instruções de configuração, consulte
Configurar perfis de armazenamento.
Criar uma rede virtual
As VMs conectam-se a uma rede virtual usando uma interface de rede virtual. A rede virtual permite que elas se comuniquem com outras VMs no cluster ou com recursos fora do cluster.
Neste tutorial, você cria uma rede virtual básica de camada 2 (L2
) que pode usar um servidor DHCP externo. Ao ativar o uso de um servidor DHCP externo, é possível pular as configurações de DNS e gateway se elas são fornecidas pelo DHCP.
Para criar uma rede que usa um servidor DHCP externo, siga as etapas a seguir:
Crie um manifesto de
Network
, comodhcp-network.yaml
, no editor de 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 nó do Google Distributed Cloud a que a rede será anexada. Todos os nós precisam ter o mesmo nome de interface.
Nesse manifesto
Network
, os seguintes valores são definidos:- As cargas de trabalho podem ter apenas um anexo
L2
para essa rede. Essa é a única redetype
que pode ser criada no ambiente de execução da VM no GDC. - O DHCP externo está ativado na rede. O servidor DHCP externo é responsável pela configuração de alocação de endereços IPv4, rotas, gateway e DNS para cargas de trabalho conectadas a essa rede.
Salve e feche o manifesto
Network
no seu editor.Crie a rede usando
kubectl
:kubectl apply -f use-dhcp-network.yaml
Criar um disco de inicialização de VM
Uma VM pode usar uma imagem de disco pré-criada ou inicializar a partir de uma imagem ISO para instalar manualmente o SO. Essas imagens de disco podem ser armazenadas e acessadas usando HTTP ou no Cloud Storage e acessadas usando um Secret
.
Neste tutorial, você criará um disco de inicialização a partir da imagem de nuvem pública do Ubuntu Server 20.04 usando HTTP.
Para criar um disco com base em uma imagem, siga as etapas abaixo.
Crie um manifesto de
VirtualMachineDisk
, comomy-disk.yaml
, no editor de sua escolha:nano my-disk.yaml
Copie e cole a seguinte definição de 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 escolhido para o disco. Este exemplo cria um disco20Gi
(20 gibibyte) chamadoDISK_NAME
usando uma imagem pública do Ubuntu Server 20.04.STORAGE_CLASS_NAME
: aStorageClass
que você quer usar para oVirtualMachineDisk
.- Use
kubectl get storageclass
para listar o que está disponível no cluster.
- Use
Salve e feche o manifesto
VirtualMachineDisk
no seu editor.Crie o disco usando
kubectl
:kubectl apply -f my-disk.yaml
Criar uma VM
Com uma rede virtual e um disco de inicialização criados nas seções anteriores, agora crie uma VM. A VM conecta-se à rede virtual e é inicializada pelo disco virtual. As instruções a seguir criam uma VM ao aplicar diretamente um
arquivo de manifesto YAML VirtualMachine
com a CLI kubectl
.
Crie um manifesto que defina um
VirtualMachine
, comomy-vm.yaml
, no editor que você escolher:nano my-vm.yaml
Copie e cole a seguinte definição de 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 VM.VCPU_NUMBER
: o número de vCPUs opcionais a serem atribuídas à VM. Sem essa configuração, o padrão de duas vCPUs é atribuído.- É possível atribuir de 1 a 96 vCPUs a uma VM.
MEMORY_SIZE
: a quantidade de memória opcional a ser atribuída à VM. Sem essa configuração, o padrão de 4 GiB de memória é atribuído.- É possível atribuir entre 1M e 1T de memória a uma VM. Para mais informações, consulte Unidades de recurso de memória.
NETWORK_NAME
: o nome da rede criada em uma seção anterior.DISK_NAME
: o nome do disco de inicialização criado na seção anterior. Esse disco é definido comoboot: true
.
Salve e feche o manifesto no editor.
Crie a VM e o disco usando
kubectl
:kubectl apply -f my-vm.yaml
Pode levar alguns minutos para criar a instância. Verifique o status da VM com o comando kubectl:
kubectl get gvm VM_NAME
O exemplo de saída a seguir mostra a VM em um estado
Running
:NAME STATUS AGE IP MY_VM Running 64s 192.168.2.124
Conectar-se à VM
Quando sua VM estiver em execução, conecte-se ao console dela. Com essa conexão do console, é possível realizar tarefas básicas, como configurar ainda mais a VM ou instalar um aplicativo.
Para acessar uma VM no console, execute
kubectl
:kubectl virt console VM_NAME
Quando solicitado, digite as credenciais de usuário que você especificou para criar a VM.
Depois de se conectar ao console da VM, saia da sessão e do console da VM:
Ctrl + ]
Editar a VM
Durante o ciclo de vida da VM, convém editar a VM. Por exemplo, convém adicionar armazenamento para instalar um aplicativo em um disco dedicado ou usar armazenamento extra para o aplicativo.
Neste tutorial, crie um disco em branco e o anexe à VM. Esse cenário permite criar um disco para armazenar dados do aplicativo.
Crie um manifesto de
VirtualMachineDisk
, comomy-data-disk.yaml
, no editor de sua escolha:nano my-data-disk.yaml
Copie e cole a seguinte definição de 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 escolhido para o disco de dados. Este exemplo cria um disco10Gi
(10 gibibyte).STORAGE_CLASS_NAME
: aStorageClass
que você quer usar para oVirtualMachineDisk
.- Use
kubectl get storageclass
para listar o que está disponível no cluster.
- Use
Salve e feche o manifesto do disco no editor.
Crie o disco usando
kubectl
:kubectl apply -f my-data-disk.yaml
Use
kubectl
para interromper a VM antes de anexar o novo disco virtual:kubectl virt stop VM_NAME
Edite o recurso da VM:
kubectl edit gvm VM_NAME
Atualize o manifesto YAML da
VirtualMachine
para anexar o disco ao final da seçãospec.disks
da VM: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 na etapa anterior.Salve e feche o manifesto da VM atualizado no editor.
Use
kubectl
para iniciar a VM:kubectl virt start VM_NAME
Limpar
Para excluir os recursos criados neste tutorial, siga estas etapas:
Exclua a VM:
kubectl delete -f my-vm.yaml
Exclua os recursos do
VirtualMachineDisk
:kubectl delete -f my-data-disk.yaml kubectl delete -f my-disk.yaml
Se você não quiser manter as dependências básicas no cluster, siga estas etapas:
Exclua a rede virtual:
kubectl delete -f use-dhcp-network.yaml
Para remover o driver CSI do cluster, siga as instruções do parceiro de armazenamento.