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á ativado no Distributed Cloud Connected. Se você precisar ativar manualmente, siga as etapas desta seção. As instruções nesta seção pressupõem que você tenha um cluster conectado do Distributed Cloud totalmente funcional. Para desativar o suporte máquina virtual do ambiente de execução de VM no GDC no seu cluster, desfaça as mudanças descritas nesta seção.

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 usando o Google Cloud console

Para criar uma máquina virtual usando o console do Google Cloud , faça o seguinte:

  1. No Google Cloud console, acesse a página Clusters.

    Acessar Clusters

  2. Selecione o projeto de destino Google Cloud .

  3. (Opcional) Se você ainda não tiver feito isso, faça login no cluster de destino:

    1. No painel de navegação à esquerda, clique em Clusters.

    2. Na lista Clusters gerenciados do Anthos, clique no cluster de destino.

    3. No painel de informações à direita, clique em FAZER LOGIN.

    4. Na caixa de diálogo pop-up que aparece, selecione seu método de autenticação preferido, insira suas credenciais e clique em FAZER LOGIN.

  4. Acesse a página Máquinas virtuais.

    Acessar "Máquinas virtuais"

  5. Clique em CRIAR.

  6. Na seção Noções básicas, faça o seguinte:

    1. No campo Nome, insira um nome significativo para a máquina virtual.

    2. No campo Selecionar cluster, escolha o cluster de destino da máquina virtual.

    3. No campo Namespace, selecione o namespace de destino.

    4. No campo Tipo de SO, selecione o sistema operacional de destino.

    5. (Opcional) Se quiser adicionar um ou mais rótulos à configuração da máquina virtual, clique em ADICIONAR RÓTULO.

  7. Na seção Configuração da máquina, faça o seguinte:

    • Se você quiser especificar o número de vCPUs e a quantidade de memória para essa máquina virtual, selecione Configuração personalizada, insira os valores de destino e clique em PRÓXIMA.

    • Se você quiser usar um número predeterminado de vCPUs e uma quantidade de memória para essa máquina virtual, selecione Configuração padrão, escolha uma configuração de máquina na lista suspensa Tipo de máquina e clique em PRÓXIMA.

  8. Na seção Armazenamento, faça o seguinte:

    • Se você quiser criar um novo disco virtual para essa máquina virtual, selecione Adicionar um novo disco e digite um nome significativo no campo Nome, um tamanho em gigabytes no campo GiB e um URL no campo Imagem.

    • Se você quiser usar um disco virtual para essa máquina virtual, selecione Selecionar um disco existente e escolha a imagem de disco de destino na lista suspensa Selecionar um disco.

    • Especifique se você quer que o disco seja somente leitura e se ele será excluído automaticamente quando esta máquina virtual for excluída usando as caixas de seleção Somente leitura e Exclusão automática.

    • Especifique um driver de disco virtual na lista suspensa Driver.

    • Para adicionar outro disco a essa máquina virtual, clique em ADICIONAR UM DISCO na seção Discos extras.

    • Clique em PRÓXIMA.

  9. Na seção Rede, faça o seguinte:

    1. Na subseção Interface de rede padrão, especifique o nome da interface de rede principal para essa máquina virtual no campo Nome da interface.

    2. Selecione o tipo de rede correspondente na lista suspensa Tipo de rede.

    3. Especifique se quer permitir o acesso externo a essa interface de rede usando a caixa de seleção Permitir acesso externo. Se você ativar essa opção, insira uma lista separada por vírgulas de portas para exposição externa no campo Portas expostas.

    4. Se quiser adicionar uma ou mais interfaces de rede secundárias a essa máquina virtual, clique em ADICIONAR UMA INTERFACE DE REDE.

    5. Clique em PRÓXIMA.

  10. Na seção Opções avançadas, use a caixa de seleção Reinicialização automática na atualização para especificar se a máquina virtual será reiniciada depois que o software conectado do
    Distributed Cloud no cluster de destino for atualizado.

  11. Na seção Firmware, faça o seguinte:

    1. Selecione o tipo de firmware de destino no campo Tipo de carregador de inicialização. Se você selecionar o firmware UEFI, poderá ativar a inicialização segura usando a caixa de seleção Inicialização segura.

    2. Especifique um número de série para essa máquina virtual no campo Serial.

    3. Especifique um identificador universal exclusivo (UUID) para essa máquina virtual no campo UUID.

  12. Na seção Cloud-init, faça o seguinte:

    • Especifique um valor de secret de dados de rede no campo Secret de dados de rede.

    • Especifique um valor secreto de dados do usuário no campo Segredo de dados do usuário.

  13. Clique em CRIAR VM para criar a máquina virtual.

Criar uma máquina virtual com um arquivo YAML

Para criar uma máquina virtual usando um arquivo de configuração YAML, faça o seguinte:

  1. No Google Cloud console, acesse a página Clusters.

    Acessar Clusters

  2. Selecione o projeto de destino Google Cloud .

  3. (Opcional) Se você ainda não tiver feito isso, faça login no cluster de destino:

    1. No painel de navegação à esquerda, clique em Clusters.

    2. Na lista Clusters gerenciados do Anthos, clique no cluster de destino.

    3. No painel de informações à direita, clique em FAZER LOGIN.

    4. Na caixa de diálogo pop-up que aparece, selecione seu método de autenticação preferido, insira suas credenciais e clique em FAZER LOGIN.

  4. Acesse a página Máquinas virtuais.

    Acessar "Máquinas virtuais"

  5. Clique em CRIAR COM YAML.

  6. No campo Selecionar cluster, escolha o cluster de destino da máquina virtual.

  7. Cole a configuração da máquina virtual no formato YAML no campo YAML.

  8. Clique em CRIAR.

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.

Iniciar ou parar uma máquina virtual usando o console Google Cloud

  1. No Google Cloud console, acesse a página Clusters.

    Acessar Clusters

  2. Selecione o projeto de destino Google Cloud .

  3. (Opcional) Se você ainda não tiver feito isso, faça login no cluster de destino:

    1. No painel de navegação à esquerda, clique em Clusters.

    2. Na lista Clusters gerenciados do Anthos, clique no cluster de destino.

    3. No painel de informações à direita, clique em FAZER LOGIN.

    4. Na caixa de diálogo exibida, selecione seu método de autenticação preferido, insira suas credenciais e clique em FAZER LOGIN.

  4. Acesse a página Máquinas virtuais.

    Acessar "Máquinas virtuais"

  5. Na lista de máquinas virtuais, marque as caixas de seleção das máquina virtual de destino.

  6. Na parte de cima da página, clique em INICIAR ou PARAR, conforme aplicável.

Ver o status de uma máquina virtual usando o console Google Cloud

  1. No Google Cloud console, acesse a página Clusters.

    Acessar Clusters

  2. Selecione o projeto de destino Google Cloud .

  3. (Opcional) Se você ainda não tiver feito isso, faça login no cluster de destino:

    1. No painel de navegação à esquerda, clique em Clusters.

    2. Na lista Clusters gerenciados do Anthos, clique no cluster de destino.

    3. No painel de informações à direita, clique em FAZER LOGIN.

    4. Na caixa de diálogo pop-up que aparece, selecione seu método de autenticação preferido, insira suas credenciais e clique em FAZER LOGIN.

  4. Acesse a página Máquinas virtuais.

    Acessar "Máquinas virtuais"

  5. Clique na máquina virtual de destino.

  6. Na página que aparece, clique nas guias Detalhes, Eventos e YAML para conferir as informações correspondentes sobre essa máquina virtual.

Modificar uma máquina virtual

Para modificar uma máquina virtual, é necessário excluí-la e recriá-la com a configuração atualizada.

Excluir uma máquina virtual usando o console Google Cloud

  1. No Google Cloud console, acesse a página Clusters.

    Acessar Clusters

  2. Selecione o projeto de destino Google Cloud .

  3. (Opcional) Se você ainda não tiver feito isso, faça login no cluster de destino:

    1. No painel de navegação à esquerda, clique em Clusters.

    2. Na lista Clusters gerenciados do Anthos, clique no cluster de destino.

    3. No painel de informações à direita, clique em FAZER LOGIN.

    4. Na caixa de diálogo exibida, selecione seu método de autenticação preferido, insira suas credenciais e clique em FAZER LOGIN.

  4. acesse a página Máquinas virtuais.

    Acessar "Máquinas virtuais"

  5. Na lista de máquinas virtuais, marque a caixa de seleção da máquina virtual de destino.

  6. Na parte superior da página, clique em EXCLUIR.

  7. Na caixa de diálogo de confirmação, insira o nome da máquina virtual e clique em EXCLUIR.

Fazer backup de uma máquina virtual

Nesta seção, descrevemos como configurar seu ambiente para fazer backup das cargas de trabalho da máquina virtual e como gerenciar os backups. Para ativar esse recurso, entre em contato com seu representante do Google.

Pré-requisitos

  1. Se você ainda não fez isso, crie o recurso personalizado robin-block-immediate do tipo StorageClass com o seguinte conteúdo e aplique-o ao cluster:

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

  2. Se você ainda não fez isso, crie um recurso personalizado robin-snapshotclass do tipo VolumeSnapshotClass com o seguinte conteúdo e aplique-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

Criar um repositório de backup on-line

Um repositório de backup on-line é um local de armazenamento on-line compatível com S3 para seus backups de máquina virtual. Ele também armazena registros de backups, planos de backup e planos de restauração, além de servir como destino para restaurar backups de máquina virtual.

Siga estas etapas para criar um repositório de backup on-line para suas máquinas virtuais:

  1. Crie um bucket do Cloud Storage conforme descrito em Criar buckets.

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

    export PROJECT_ID=$(gcloud config get-value project)
export SVC_ACCOUNT=backup-access
gcloud iam service-accounts create $SVC_ACCOUNT
gcloud projects add-iam-policy-binding $PROJECT_ID \ 
   --member="serviceAccount:${SVC_ACCOUNT}@${PROJECT_ID}.iam.gserviceaccount.com" \
   --role="roles/backupdr.cloudStorageOperator"
gcloud storage hmac create  ${SVC_ACCOUNT}@${PROJECT_ID}.iam.gserviceaccount.com > hmac_temp_key_file
awk 'NR==1{print "ACCESS_ID=" $NF} NR==2{print "SECRET=" $NF}' < hmac_temp_key_file > hmac_key_file

  3. Configure o secret para acessar o bucket de backup usando os seguintes comandos:

    source ./hmac_key_file
kubectl create secret generic SECRET_NAME \
   --from-literal=access-key=$SECRET \
   --from-literal=access-key-id=$ACCESS_ID -n NAMESPACE

    Substitua:

    • SECRET_NAME: um nome descritivo para esse secret.
    • NAMESPACE: o namespace de destino.

  4. Crie o recurso BackupRepository aplicando a seguinte configuração ao cluster:

    apiVersion: backup.gdc.goog/v1
kind: BackupRepository
metadata:
  name: "REPOSITORY_NAME"
spec:
  secretReference:
    namespace: NAMESPACE
    name: gcs-hmac-secret
  endpoint: "https://storage.googleapis.com"
  type: "S3"
  s3Options:
    bucket: "BUCKET_NAME"
    region: "REGION"
    forcePathStyle: true
  importPolicy: "ReadWrite"
# Force attachment for convenience.
force: true

    Substitua:

    • REPOSITORY_NAME: um nome descritivo para o repositório.
    • BUCKET_NAME: o nome do bucket de backup.
    • NAMESPACE: o namespace de destino.
    • REGION: a região Google Cloud em que o cluster de destino do Distributed Cloud foi criado.

  5. Verifique se o cluster pode acessar o repositório de backup usando o seguinte comando:

    kubectl get BackupRepository

Criar um repositório de backup local

Um repositório de backup local é um local de armazenamento compatível com S3 para backups máquina virtual que reside localmente no cluster conectado do Distributed Cloud. Um repositório de backup local é funcionalmente idêntico a um repositório de backup on-line.

  1. Gere uma chave de criptografia AES256 para usar na criptografia de configuração no nível do aplicativo:

    openssl rand -base64 32

    O comando gera uma chave aleatória de 256 bits codificada em base64. Exemplo:

    aBcD_eFgH1iJkLmN0pQrStUvWxFyZgAhIjKlMnOpQ=

  2. Faça a codificação dupla da chave para usar como payload na configuração YAML do recurso BackupRepository:

    echo -n "AES_KEY" | base64

    Substitua AES_KEY pela chave AES256 codificada em base64 que você gerou na etapa anterior. Armazene essa chave em um arquivo local.

  3. Configure o secret para acessar o repositório de backup usando os seguintes comandos:

    kubectl create secret generic SECRET_NAME \
   --from-literal=access-key=ENCODED_AES_KEY \
   --namespace NAMESPACE

    Substitua:

    • ENCODED_AES_KEY: a chave AES256 com codificação dupla que você gerou na etapa anterior.
    • SECRET_NAME: um nome descritivo para esse secret.
    • NAMESPACE: o namespace de destino.

  4. Configure o BackupRepository aplicando a seguinte configuração ao cluster:

    apiVersion: backup.gdc.goog/v1
kind: BackupRepository
metadata:
  name: REPOSITORY_NAME
spec:
  force: true
  importPolicy: ReadWrite
  localOptions:
    encryptionKey:
      name: SECRET_NAME
      namespace: NAMESPACE
  type: Local

  5. Verifique se o cluster pode acessar o repositório de backup usando o seguinte comando:

    kubectl get BackupRepository

    Substitua:

    • REPOSITORY_NAME: um nome descritivo para o repositório.
    • SECRET_NAME: o nome do secret do Kubernetes criado na etapa anterior.
    • NAMESPACE: o namespace em que você criou o secret do Kubernetes.

Criar um plano de backup

Um plano de backup define o agendamento automatizado para executar o backup da máquina virtual. Crie um recurso VirtualMachineBackupPlan com o conteúdo a seguir e aplique ao cluster:

apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineBackupPlan
metadata:
  name: BACKUP_PLAN_NAME
  namespace: NAMESPACE
spec:
  backupConfig:
    backupRepository: REPOSITORY_NAME
    backupScope:
      selectedVirtualMachines:
      - resourceName: VM_NAME
    volumeStrategy: LocalSnapshotOnly
  backupSchedule:
    cronSchedule: "CRON_SCHEDULE"
    paused: PAUSED
  retentionPolicy:
    backupDeleteLockDays: PLAN_LOCK_LENGTH
    backupRetainDays: 4
    locked: RETENTION_POLICY_LOCKED
  numBackupsToRetain: BACKUPS_RETAINED

Substitua:

  • BACKUP_PLAN_NAME: um nome descritivo para o plano de backup.
  • NAMESPACE: o nome do namespace de destino.
  • REPOSITORY_NAME: o repositório de backup de destino.
  • CRON_SCHEDULE: cron: programação padrão para executar os backups. O intervalo mínimo permitido entre backups é de 10 minutos.
  • PAUSED: especifica se o plano de backup está pausado. Os valores válidos são true e false.
  • VM_NAME: especifica uma carga de trabalho de máquina virtual a ser armazenada em backup por este plano de backup. É possível especificar vários recursos de máquina virtual por plano de backup.
  • * BACKUP_LOCK_LENGTH: especifica o número de dias após a criação do backup em que ele não pode ser excluído.
  • * BACKUP_RETENTION_LENGTH: especifica o número de dias para manter esse backup. Quando o período de armazenamento expira, o backup é excluído. Se omitido, o padrão é 4.
  • * RETENTION_POLICY_LOCKED: especifica se a política de retenção deste plano de backup está bloqueada. Os valores válidos são true e false.
  • * BACKUPS_RETAINED/var>: especifica o número de backups a serem mantidos neste plano de backup. Quando esse limite é atingido, os backups são excluídos na ordem do mais antigo para o mais recente.

Listar planos de backup atuais

Para listar os planos de backup atuais, use o seguinte comando:

kubectl get VirtualMachineBackupPlans -A

O comando retorna uma saída semelhante a esta:

NAMESPACE      NAME                                LASTBACKUPTIME   LASTBACKUPSTATE   NEXTBACKUPTIME   PAUSED
vm-workloads   bkp-template-vm-windows-vm-local
vm-workloads   sched-snapshotonly-bkp-plan-10min                                                       false

Criar um backup manual de uma máquina virtual

Siga as etapas desta seção para criar um backup manual de uma máquina virtual.

  1. Crie um recurso VirtualMachineBackupPlanTemplate no namespace em que a máquina virtual de destino reside aplicando a seguinte configuração ao cluster:

    apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineBackupPlanTemplate
metadata:
  name: TEMPLATE_NAME
  namespace: NAMESPACE
spec:
  backupRepository: REPOSITORY_NAME

    Substitua:

    • TEMPLATE_NAME: um nome descritivo para esse modelo de backup.
    • REPOSITORY_NAME: o nome do repositório de backup de destino.
    • NAMESPACE: o namespace de destino.

  2. Para acionar o backup, crie um recurso VirtualMachineBackupRequest com a seguinte configuração e aplique-o ao cluster:

    apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineBackupRequest
metadata:
  name: BACKUP_REQUEST_NAME
  namespace: NAMESPACE
spec:
  vmBackupPlanTemplate: TEMPLATE_NAME
  virtualMachine: VM_NAME
  vmBackupName: BACKUP_NAME

    Substitua:

    • BACKUP_REQUEST_NAME: um nome descritivo para essa solicitação de backup.
    • TEMPLATE_NAME: o nome do modelo de backup que você criou na etapa anterior.
    • NAMESPACE: o nome do namespace de destino.
    • VM_NAME: o nome da máquina virtual de destino.
    • BACKUP_NAME: um nome descritivo para o backup.

  3. Verifique a integridade do backup com o seguinte comando:

    kubectl get vmbackup BACKUP_NAME -n NAMESPACE

    Substitua:

    • BACKUP_NAME: o nome do backup de destino.
    • NAMESPACE: o namespace de destino.

    O comando retorna uma saída semelhante a esta:

    apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineBackup
metadata:
  creationTimestamp: "2024-04-09T17:57:44Z"
  finalizers:
  - vm.cluster.gke.io/virtual-machine-backup-finalizer
  generation: 1
  name: vmt13-backup-0409-2
  namespace: default
  ownerReferences:
  - apiVersion: backup.gdc.goog/v1
    kind: Backup
    name: vmt13-backup-0409-2
    uid: 0ee0b92c-1e27-48cc-8f8f-5606ea925e88
  resourceVersion: "36192759"
  uid: e471f8c7-637c-485f-acda-108017a5638f
spec:
  backupConfig:
    backupRepository: default
    backupScope:
      selectedVirtualMachines:
      - resourceName: vm-t13
    volumeStrategy: Portable
  vmBackupPlan: MyVmPlan-vm-vm-t13-portable
status:
  backedUpVirtualMachineDisks:
  - vm-t13-boot-disk
  - vm-t13-data-disk
  backedUpVirtualMachines:
  - vm-t13
  backup: vmt13-backup-0409-2
  backupStatus:
    clusterMetadata:
      k8sVersion: "1.28"
    completeTime: "2024-04-09T18:07:36Z"
    createTime: "2024-04-09T17:57:44Z"
    jobCreated: true
    resourceCount: 849
    sizeBytes: 1948672
    state: Succeeded

Listar backups máquina virtual

Para conferir os backups máquina virtual atuais, use o seguinte comando:

kubectl get VirtualMachineBackups -A

O comando retorna uma saída semelhante a esta:

NAMESPACE      NAME        STATE       CREATETIME
vm-workloads   vm-backup   Succeeded   2025-04-08T04:37:32Z

Restaurar uma máquina virtual de um backup

Conclua as etapas nesta seção para restaurar uma máquina virtual de um backup.

  1. Acione o processo de restauração criando um recurso VirtualMachineRestoreRequest com a seguinte configuração e aplicando-o ao cluster:

    apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineRestoreRequest
metadata:
  name: restore-req
  namespace: NAMESPACE
spec:
  vmBackup: BACKUP_NAME
  restoreName: RESTORE_NAME
  restoredResourceName: RESTORED_VM_NAME
  restoredResourceDescription: RESTORE_DESCRIPTION

    Substitua:

    • BACKUP_NAME: o nome do backup de destino.
    • RESTORE_NAME: um nome descritivo para essa operação de restauração.
    • NAMESPACE: o namespace de destino.
    • RESTORED_VM_NAME: o nome dado à máquina virtual durante a restauração. Ele não pode entrar em conflito com nenhuma máquina virtual já presente no cluster.
    • RESTORE_DESCRIPTION: uma descrição para esta operação de restauração.

  2. Use o comando a seguir para verificar o progresso da operação de restauração:

    kubectl get virtualmachinerestores.vm.cluster.gke.io RESTORE_NAME -n NAMESPACE

    Substitua:

    • RESTORE_NAME: o nome da operação de restauração de destino.
    • NAMESPACE: o namespace de destino.

    O comando retorna uma saída semelhante a esta:

    apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineRestore
metadata:
  creationTimestamp: "2024-04-09T18:09:51Z"
  finalizers:
  - vm.cluster.gke.io/virtual-machine-restore-finalizer
  generation: 1
  name: vmt13-restore-0409-2-1
  namespace: default
  ownerReferences:
  - apiVersion: backup.gdc.goog/v1
    kind: Restore
    name: vmt13-restore-0409-2-1
    uid: 4ce1ca83-eba0-4cc3-bad3-af6cf9185d7d
  resourceVersion: "36194596"
  uid: aba50b59-e18d-4687-ad11-47baa45478b4
spec:
  targetVirtualMachineDisks:
  - vm-t13-boot-disk
  - vm-t13-data-disk
  targetVirtualMachines:
  - vm-t13
  vmBackup: vmt13-backup-0409-2
status:
  restore: vmt13-restore-0409-2-1
  restoreStatus:
    completeTime: "2024-04-09T18:10:00Z"
    jobCreated: true
    resourcesRestoredCount: 5
    restoredVolumesCount: 2
    startTime: "2024-04-09T18:09:51Z"
    state: Succeeded
    stateReason: restore is successful

Conferir operações de restauração

Para conferir as operações de restauração iniciadas até o momento, use o seguinte comando:

kubectl get VirtualMachineRestore.vm.cluster.gke.io -A

O comando retorna uma saída semelhante a esta:

NAMESPACE      NAME        STARTTIME              RESTORE     STATE
vm-workloads   restore-1   2025-04-08T04:41:04Z   restore-1   Succeeded

Excluir um backup de máquina virtual

Para excluir um backup de máquina virtual, crie um recurso VirtualMachineDeleteBackupRequest com a seguinte configuração e aplique-o ao cluster:

    apiVersion: vm.cluster.gke.io/v1
    kind: VirtualMachineDeleteBackupRequest
    metadata:
      name: vmdbr
      namespace: BACKUP_NAME
    spec:
      vmBackup: NAMESPACE

Substitua:

  • NAMESPACE: o nome do namespace de destino.
  • BACKUP_NAME: o nome do backup de destino.

Acessar registros de auditoria do sandbox do AppArmor

O Distributed Cloud conectado automaticamente coloca em sandbox as cargas de trabalho máquina virtual com políticas AppArmor em audit-mode. Uma violação de política gera uma entrada de registro de auditoria. Exemplo:

{
  "jsonPayload": {
    "_SOURCE_REALTIME_TIMESTAMP": "1734596844149104",
    "SYSLOG_TIMESTAMP": "Dec 19 08:27:24 ",
    "MESSAGE": "type=AVC msg=audit(1734596844.148:27742): apparmor=\"ALLOWED\" operation=\"open\" profile=\"virt-launcher-audit\" name=\"/etc/libvirt/virtlogd.conf\" pid=182406 comm=\"virtlogd\" requested_mask=\"r\" denied_mask=\"r\" fsuid=0 ouid=0 FSUID=\"root\" OUID=\"root\"",
    "PRIORITY": "6",
    ...
    "SYSLOG_RAW": "<14>Dec 19 08:27:24 audisp-syslog: type=AVC msg=audit(1734596844.148:27742): apparmor=\"ALLOWED\" operation=\"open\" profile=\"virt-launcher-audit\" name=\"/etc/libvirt/virtlogd.conf\" pid=182406 comm=\"virtlogd\" requested_mask=\"r\" denied_mask=\"r\" fsuid=0 ouid=0 FSUID=\"root\" OUID=\"root\"\n",
    "SYSLOG_IDENTIFIER": "audisp-syslog",
    "_GID": "0",
  },
  "timestamp": "2024-12-19T08:27:24.149109Z",
  "labels": {
    "gke.googleapis.com/log_type": "system"
  },
  "receiveTimestamp": "2024-12-19T08:27:24.721842807Z"
  ...
  ...
}

A seguir