Gerenciar máquinas virtuais em servidores conectados do Distributed Cloud

Nesta página, descrevemos como gerenciar máquinas virtuais em servidores conectados do Google Distributed Cloud que executam o ambiente de execução de VM no Google Distributed Cloud. É necessário conhecer o ambiente de execução de VM no GDC antes de concluir as etapas nesta página. Para uma lista de sistemas operacionais convidados compatíveis, consulte Sistemas operacionais convidados verificados para o ambiente de execução de VMs no GDC.

Para saber como as máquinas virtuais servem como um componente essencial da plataforma conectada do Distributed Cloud, consulte Extensão do GKE Enterprise para gerenciar VMs de borda locais.

Os clusters conectados do Distributed Cloud são compatíveis com webhooks máquina virtual. Isso permite que o Distributed Cloud Connected valide as solicitações de usuários feitas ao servidor da API Kubernetes local. As solicitações rejeitadas geram informações detalhadas sobre o motivo da rejeição.

Configurar o armazenamento do Symcloud

Os servidores conectados do Google Distributed Cloud usam o Rakuten Symcloud Storage como solução de armazenamento. O Symcloud Storage é uma solução de terceiros que atua como uma camada de abstração de armazenamento local em cada nó conectado do Distributed Cloud e disponibiliza o armazenamento local para cargas de trabalho executadas em outros nós conectados do Distributed Cloud.

O Symcloud Storage é implantado no Google Cloud Marketplace e está sujeito aos termos declarados nele. O Google oferece suporte limitado para o uso do Symcloud Storage com o Distributed Cloud Connected e pode contratar o provedor terceirizado para receber ajuda. As atualizações de software do Symcloud Storage estão incluídas nas atualizações de software conectadas do Distributed Cloud.

Configure seu cluster conectado do Google Distributed Cloud da seguinte maneira para ativar o armazenamento do Symcloud para máquinas virtuais:

  1. Crie o namespace robinio com o seguinte comando:

    kubectl create ns robinio

  2. Obtenha o arquivo de licença do Symcloud Storage e aplique-o ao cluster com o seguinte comando:

    kubectl apply LICENSE_FILE

  3. Verifique se o Symcloud Storage está em execução com o seguinte comando:

    kubectl apply LICENSE_FILE

    O comando retorna uma saída semelhante a esta:

     Name:         robin
 Namespace:
 Labels:       app.kubernetes.io/instance=robin
               app.kubernetes.io/managed-by=robin.io
               app.kubernetes.io/name=robin
 Annotations:  <none>
 API Version:  manage.robin.io/v1
 Kind:         RobinCluster
 Metadata:
   …
 Spec:
   …
 Status:
   …
   Phase:             Ready
   …

  4. Crie a classe de armazenamento robin-block-immediate aplicando a seguinte configuração ao cluster:

    apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: robin-block-immediate
parameters:
  faultdomain: host
  replication: "3"
  blocksize:   "512"
provisioner: robin
reclaimPolicy: Delete
volumeBindingMode: Immediate
allowVolumeExpansion: true

  5. Crie a classe de snapshot de volume robin-snapshotclass aplicando a seguinte configuração ao cluster:

    apiVersion: snapshot.storage.k8s.io/v1
kind: VolumeSnapshotClass
metadata:
  name: robin-snapshotclass
  labels:
    app.kubernetes.io/instance: robin
    app.kubernetes.io/managed-by: robin.io
    app.kubernetes.io/name: robin
  annotations:
    snapshot.storage.kubernetes.io/is-default-class: "true"
driver: robin
deletionPolicy: Delete

Ativar o suporte do ambiente de execução de VMs no GDC no Distributed Cloud Connected

Por padrão, o suporte a máquina virtual do ambiente de execução de VMs no GDC está desativado no Distributed Cloud Connected. Para ativar, siga as etapas nesta seção. As instruções nesta seção pressupõem que você tenha um cluster conectado do Distributed Cloud totalmente funcional.

Para ativar o ambiente de execução de VMs no subsistema de máquina virtual do GDC, siga estas etapas:

  1. Modifique o recurso personalizado VMRuntime com o conteúdo a seguir e aplique-o ao cluster:

    apiVersion: vm.cluster.gke.io/v1
kind: VMRuntime
metadata:
  annotations:
    baremetal.cluster.gke.io/vmrumtime-force-disable: "false"
    vm.cluster.gke.io/enable-vm-backup: "true"
spec:
  enabled: true
  storage:
    defaultStorageClass: robin-block-immediate
haPolicy:
  defaultRecoveryStrategy: Reschedule
  nodeHeartbeatInterval: 15s
  nodeMonitorGracePeriod: 55s

    Esse processo geralmente leva alguns minutos para ser concluído.

  2. Use o seguinte comando para verificar se o recurso personalizado VMRuntime foi aplicado ao cluster:

    kubectl get vmruntime

    O comando retorna uma saída semelhante a este exemplo:

    NAME        AGE   ENABLED   READY   PREFLIGHTCHECK
vmruntime   5m   true      true    true

  3. Modifique o storageprofile para a classe de armazenamento robin-block-immediate com o seguinte conteúdo e aplique ao cluster:

    apiVersion: cdi.kubevirt.io/v1beta1
kind: StorageProfile
metadata:
  name: robin-block-immediate
spec:
  claimPropertySets:
    accessModes:
      ReadWriteMany
  volumeMode: Block

Instalar a ferramenta de gerenciamento virtctl

Você precisa da ferramenta de cliente virtctl para gerenciar máquinas virtuais no cluster conectado do Distributed Cloud. Para instalar a ferramenta, siga estas etapas:

  1. Instalar a ferramenta do cliente virtctl como um plug-in kubectl

    export VERSION=v0.59.0-anthos1.28-gke.8
gcloud storage cp gs://anthos-baremetal-release/virtctl/${VERSION}/linux-amd64/virtctl/usr/local/bin/virtctl
cd /usr/local/bin
sudo ln -s virtctl kubectl-virt
sudo chmod a+x virtctl
cd -

  2. Verifique se o plug-in virt está instalado:

    kubectl plugin list

    Se o plug-in tiver sido instalado, a saída do comando vai listar kubectl-virt como um dos plug-ins.

Criar um bucket do Cloud Storage para imagens máquina virtual

Siga as etapas desta seção para criar um bucket do Cloud Storage para suas imagens de máquina virtual. Se você já tiver um repositório de imagens estabelecido, pule esta seção.

  1. Siga as etapas em Criar buckets para criar um bucket.

  2. Configure uma conta de serviço e uma chave para acessar o bucket com os seguintes comandos:

    export PROJECT_ID=$(gcloud config get-value project)
gcloud iam service-accounts create image-access
gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:image-access@${PROJECT_ID}.iam.gserviceaccount.com" \
  --role="roles/storage.objectViewer" \
gcloud iam service-accounts keys create ./image-access-gcr.json \
  --iam-account="image-access@${PROJECT_ID}.iam.gserviceaccount.com"

  3. Crie um secret no cluster para acessar o bucket. Se o bucket for público, pule esta etapa. Esse secret precisa estar no mesmo namespace que os discos da máquina virtual. Crie um secret em cada namespace afetado.

    kubectl create secret generic gcs-image-sa --from-file=creds-gcp.json=./image-access-gcr.json -n NAMESPACE

    Substitua CLUSTER_ID pelo nome do namespace de destino.

  4. Armazene as imagens no bucket.

Criar um disco de máquina virtual com base em uma imagem de máquina virtual

Siga as etapas desta seção para criar um disco de máquina virtual com base em uma imagem de máquina virtual.

Criar um disco com base em uma imagem armazenada no Cloud Storage

Crie um disco de máquina virtual com base em uma máquina virtual armazenada no bucket do Cloud Storage aplicando a seguinte configuração ao cluster:

 apiVersion: vm.cluster.gke.io/v1
 kind: VirtualMachineDisk
 metadata:
   name: DISK_NAME
   namespace: NAMESPACE
 spec:
   source:
     gcs:
       url: gs://{PROJECT_ID}-vm-images/IMAGE_FILE
       secretRef: gcs-image-sa
   size: DISK_SIZE
   storageClassName: robin-block-immediate

Substitua:

  • DISK_NAME: o nome do disco da máquina virtual.
  • NAMESPACE: o namespace de destino.
  • IMAGE_FILE: o nome do arquivo de imagem da máquina virtual.
  • DISK_SIZE: o tamanho desejado do disco. Ele precisa ser maior que o valor virtual-size do arquivo de imagem da máquina virtual. É possível encontrar esse valor com o comando qemu-img info DISK_SIZE.

Se você não especificar um valor de storageClassName, o valor padrão especificado no recurso VMRuntime será usado.

Criar um disco com base em uma imagem de disco

Crie um disco de máquina virtual com base em um disco ou arquivo de imagem de máquina virtual no cluster da seguinte maneira.

  1. Crie o disco de destino aplicando a seguinte configuração ao cluster:

    apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineDisk
metadata:
  name: IMAGE_DISK_NAME
  namespace: NAMESPACE
spec:
  source:
    virtualMachineDisk:
      name: EXISTING_DISK_NAME
  size: DISK_SIZE
  storageClassName: robin-block-immediate

    Substitua:

    • IMAGE_DISK_NAME: o nome do disco da máquina virtual.
    • NAMESPACE: o namespace de destino.
    • EXISTING_DISK_NAME: o nome do disco da máquina virtual atual.
    • DISK_SIZE: o tamanho desejado do disco. Esse valor precisa ser igual ou maior que o tamanho do disco ou arquivo de imagem atual.

    Você pode usar a ferramenta qemu-img para saber o tamanho do disco ou arquivo de imagem atual da seguinte forma:

    qemu-img info EXISTING_DISK_NAME

    Se você não especificar um valor de storageClassName, o valor padrão especificado no recurso VMRuntime será usado.

  2. Crie um disco com base no arquivo de imagem atual aplicando a seguinte configuração ao cluster:

    apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineDisk
metadata:
  name: DISK_NAME
  namespace: NAMESPACE
spec:
  source:
    virtualMachineDisk:
      name: IMAGE_DISK_NAME
  size: DISK_SIZE
  storageClassName: robin-block-immediate

    Substitua:

    • IMAGE_DISK_NAME: o nome do disco da máquina virtual que você criou na etapa anterior.
    • NAMESPACE: o namespace de destino.
    • DISK_SIZE: o tamanho desejado do disco. Precisa ser igual ao tamanho do disco da máquina virtual criado na etapa anterior.

  3. Redimensione o disco de destino para o tamanho desejado usando o seguinte comando:

    kubectl edit gdisk DISK_NAME -n NAMESPACE

    Substitua:

    • DISK_NAME: o nome do disco da máquina virtual que você criou na etapa anterior.
    • NAMESPACE: o namespace de destino.

  4. Modifique o valor spec.size na configuração do disco e aplique ao cluster.

Criar um disco vazio

Crie um disco de máquina virtual vazio aplicando a seguinte configuração ao cluster:

 apiVersion: vm.cluster.gke.io/v1
 kind: VirtualMachineDisk
 metadata:
   name: DISK_NAME
   namespace: NAMESPACE
 spec:
   size: DISK_SIZE
   storageClassName: robin-block-immediate

Substitua:

  • DISK_NAME: o nome do disco da máquina virtual.
  • NAMESPACE: o namespace de destino.
  • DISK_SIZE: o tamanho desejado do disco em gibibytes. Ele precisa ser maior que o valor virtual-size do arquivo de imagem da máquina virtual. É possível encontrar esse valor com o comando qemu-img info DISK_SIZE.

Se você não especificar um valor de storageClassName, o valor padrão especificado no recurso VMRuntime será usado.

Configurar rede virtual

Siga as etapas em Rede para configurar a rede virtual das suas máquinas virtuais.

Criar uma máquina virtual

Conclua as etapas desta seção para criar uma máquina virtual na sua implantação de servidor conectado do Distributed Cloud. As instruções nesta seção são exemplos para ilustrar configurações em diferentes cenários. Para informações detalhadas sobre como configurar máquinas virtuais, consulte Criar uma VM com recursos específicos de CPU e memória usando o ambiente de execução de VM no GDC.

Criar uma máquina virtual com base em uma imagem de disco inicializável

Para criar uma máquina virtual com base em uma imagem de disco inicializável, aplique a seguinte configuração ao cluster:

 kind: VirtualMachine
 metadata:
   name: my-virtual-machine
   namespace: my-vm-namespace
 spec:
   osType: Linux/Windows
   guestEnvironment: {} // comment out this line to enable guest environment for access management
   autoRestartOnConfigurationChange: true 
   compute:
     cpu:
       vcpus: 6
     memory:
       capacity: 8Gi
   interfaces:
      - name: eth0
        networkName: network-410
        ipAddresses:
        - 10.223.237.10/25
   disks:
     - virtualMachineDiskName: my-boot-disk
       boot: true
     - virtualMachineDiskName: my-data-disk

Substitua:

  • DISK_NAME: o nome do disco da máquina virtual.
  • NAMESPACE: o namespace de destino.

Criar uma máquina virtual com base em uma imagem de disco óptico ISO

Para criar uma máquina virtual usando uma imagem de disco óptico ISO, siga as etapas em Criar uma VM do Windows usando uma imagem ISO no Google Distributed Cloud.

Criar uma máquina virtual com suporte a GPU

Conclua as etapas descritas nesta página para criar uma máquina virtual configurada para atender aos requisitos da sua empresa e, em seguida, conclua as etapas em Configurar uma máquina virtual para usar recursos de GPU.

Acessar uma máquina virtual

Conclua as etapas desta seção para acessar uma máquina virtual em execução na sua implantação de servidor conectado do Distributed Cloud.

Receber credenciais de acesso

Conclua as etapas desta seção para receber as credenciais necessárias para acessar sua máquina virtual usando o recurso de ambiente de convidado do Linux.

  1. Ative o ambiente de convidado do Linux para a máquina virtual de destino aplicando a seguinte configuração ao cluster:

    kind: VirtualMachine
metadata:
 name: my-virtual-machine
 namespace: my-vm-namespace
spec:
 osType: Linux
 guestEnvironment: {}
 autoRestartOnConfigurationChange: true

  2. Gere um arquivo id_rsa.pub contendo um par de chaves SSH com o seguinte comando:

    ssh-keygen -t rsa

  3. Crie um recurso VirtualMachineAccessRequest aplicando a seguinte configuração ao cluster:

    apiVersion: vm.cluster.gke.io/v1alpha1
kind: VirtualMachineAccessRequest
metadata:
 name: RESOURCE_NAME
 namespace: NAMESPACE
spec:
  vm: VM_NAME
  user: USER_NAME
  ssh:
    key: RSA_KEY
    ttl: 2h

Substitua:

  • RESOURCE_NAME: um nome descritivo para esse recurso de solicitação de acesso à máquina virtual.
  • NAMESPACE: o namespace de destino.
  • VM_NAME: o nome da máquina virtual de destino.
  • USER_NAME: o nome do usuário a quem o acesso está sendo concedido.
  • RSA_KEY: o conteúdo do arquivo id_rsa.pub que você gerou na etapa anterior.

  1. Verifique o status da solicitação de acesso com o seguinte comando:

    kubectl get vmar

    Quando o comando retornar um status Configured, siga para a próxima etapa.

  2. Acesse a máquina virtual com SSH ou Área de trabalho remota:

    • Se a máquina virtual estiver conectada à sua rede local, você poderá acessar diretamente.
    • Se a máquina virtual estiver conectada à rede do pod, crie um serviço de balanceador de carga para acessar as portas necessárias.

Iniciar, reiniciar ou interromper uma máquina virtual

Use os comandos a seguir para iniciar, reiniciar ou interromper uma máquina virtual:

  • Iniciar uma máquina virtual:kubectl virt start vmVM_NAME-nNAMESPACE
  • Reiniciar uma máquina virtual:kubectl virt restart vmVM_NAME-nNAMESPACE
  • Parar uma máquina virtual:kubectl virt stop vmVM_NAME-nNAMESPACE

Substitua:

  • VM_NAME: o nome da máquina virtual de destino.
  • NAMESPACE: o namespace de destino.

A seguir