Gerenciar máquinas virtuais

Nesta página, descrevemos como gerenciar máquinas virtuais na sua implantação conectada ao Google Distributed Cloud que executa 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

O Google Distributed Cloud Connected usa 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 Symcloud Storage para máquinas virtuais. Para mais informações, consulte Instalar o Symcloud Storage em um nó conectado do Distributed Cloud.

  1. Crie o namespace robin-admin com o seguinte comando:

    kubectl create ns robin-admin

  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 describe robincluster

    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

  6. 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=GDC_SO_VERSION
gcloud storage cp gs://anthos-baremetal-release/virtctl/${VERSION}/linux-amd64/virtctl ./virtctl
sudo mv ./virtctl /usr/local/bin/virtctl
cd /usr/local/bin
sudo ln -s virtctl kubectl-virt
sudo chmod a+x virtctl
cd -

    Substitua GDC_SO_VERSION pela versão de destino do Distributed Cloud somente software.

  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 de VM

Siga as etapas desta seção para criar um bucket do Cloud Storage para suas imagens de máquina virtual. O bucket usa a federação de identidade da carga de trabalho para vincular uma conta de serviço do Kubernetes à conta de serviço Google Cloud correspondente e acessar o bucket. Em outras palavras, a conta de serviço do Kubernetes simula a conta de serviço Google Cloud. Se você já tiver um repositório de imagens estabelecido, pule esta seção.

Para reduzir o risco de igualdade de identidade em uma frota de vários clusters, siga as diretrizes em Práticas recomendadas para a federação de identidade da carga de trabalho da frota ao concluir as etapas desta seção.

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

  2. Crie uma conta de serviço Google Cloud para acessar o bucket:

    export GSA_PROJECT_ID=GSA_PROJECT_ID
export GSA_NAME=GSA_NAME
gcloud iam service-accounts create ${GSA_NAME}

    Substitua:

    • GSA_NAME: um nome significativo para essa conta de serviço Google Cloud .
    • GSA_PROJECT_ID: o ID do projeto Google Cloud que hospeda a conta de serviçoGoogle Cloud de destino.

  3. Conceda à conta de serviço Google Cloud permissões para acessar o bucket:

    export BUCKET_PROJECT_ID=BUCKET_PROJECT_ID
export GSA_NAME=GSA_NAME
gcloud storage buckets add-iam-policy-binding gs://${BUCKET_PROJECT_ID}-vm-images \
   --member="serviceAccount:${GSA_NAME}@${GSA_PROJECT_ID}.iam.gserviceaccount.com" \
   --role="roles/storage.objectViewer" \
   --project=${BUCKET_PROJECT_ID}

    Substitua:

    • GSA_NAME: o nome da conta de serviço Google Cloud de destino.
    • BUCKET_PROJECT_ID: o ID do projeto Google Cloud que hospeda o bucket.
    • GSA_PROJECT_ID: o ID do projeto Google Cloud que hospeda a conta de serviçoGoogle Cloud de destino.

  4. Crie uma conta de serviço do Kubernetes no namespace da máquina virtual de destino para vincular à sua conta de serviço Google Cloud :

    export GSA_PROJECT_ID=GSA_PROJECT_ID
export VM_NAMESPACE=NAMESPACE
export KSA_NAME=KSA_NAME
export GSA_EMAIL=${GSA_NAME}@${GSA_PROJECT_ID}.iam.gserviceaccount.com
kubectl create serviceaccount ${KSA_NAME} -n ${VM_NAMESPACE}
kubectl annotate serviceaccount ${KSA_NAME} gsaEmail=${GSA_EMAIL} -n ${VM_NAMESPACE}

    Substitua:

    • GSA_PROJECT_ID: o ID do projeto Google Cloud que hospeda a conta de serviçoGoogle Cloud de destino.
    • NAMESPACE: o namespace da máquina virtual de destino.
    • KSA_NAME: um nome significativo para essa conta de serviço do Kubernetes.
    • GSA_NAME: o nome da conta de serviço Google Cloud correspondente.

  5. Encontre o nome do pool de identidades da carga de trabalho e do provedor de identidade do cluster:

    gcloud container fleet memberships describe MEMBERSHIP_ID \
    --project=FLEET_PROJECT_ID \
    --format="table(authority.identityProvider,authority.workloadIdentityPool,name)"

    Substitua:

    • MEMBERSHIP_ID: o nome da assinatura da frota do cluster. Normalmente, é o nome do cluster.
    • FLEET_PROJECT_ID: o ID do projeto host Google Cloud da frota.

    O comando retorna uma saída semelhante a esta:

    IDENTITY_PROVIDER: IDENTITY_PROVIDER
WORKLOAD_IDENTITY_POOL: WORKLOAD_IDENTITY_POOL

    Na saída, observe os seguintes valores:

  6. Vincule a conta de serviço do Kubernetes à conta de serviço Google Cloud para configurar a personificação:

    export GSA_PROJECT_ID=GSA_PROJECT_ID
export GSA_NAME=GSA_NAME
export KSA_NAME=KSA_NAME
export VM_NAMESPACE=NAMESPACE
export WI_POOL=WORKLOAD_IDENTITY_POOL
gcloud iam service-accounts add-iam-policy-binding ${GSA_NAME}@${GSA_PROJECT_ID}.iam.gserviceaccount.com \
   --project=${GSA_PROJECT_ID} \
   --role=roles/iam.workloadIdentityUser \
   --member="serviceAccount:${WI_POOL}[${VM_NAMESPACE}/${KSA_NAME}]"
   --condition="IAM_CONDITION"
   --condition-from-file="IAM_CONDITION_FILE"

    Substitua:

    • GSA_PROJECT_ID: o ID do projeto Google Cloud que hospeda a conta de serviçoGoogle Cloud de destino.
    • GSA_NAME: o nome da conta de serviço Google Cloud correspondente.
    • KSA_NAME: o nome da conta de serviço do Kubernetes de destino.
    • NAMESPACE: o namespace da máquina virtual de destino.
    • WORKLOAD_IDENTITY_POOL: o nome do pool de identidade da carga de trabalho do seu cluster.
    • IAM_CONDITION: opcional; especifica as condições do IAM para limitar o acesso a clusters específicos na frota. Se for omitido ou definido como None, nenhuma condição do IAM será aplicada.
    • IAM_CONDITION_FILE: opcional. Especifica o arquivo que contém as condições do IAM para limitar o acesso a clusters específicos na frota. Se omitido, nenhuma condição do IAM será aplicada, a menos que a flag --condition seja especificada e definida como um valor diferente de None.

  7. Armazene as imagens no bucket.

Você também pode usar o método legado com um secret gerado pela chave ativa da sua conta de serviço do Google. Para mais informações, consulte Criar um bucket do Cloud Storage para máquina virtual virtuais.

Restringir o acesso ao bucket com condições do IAM

Com as condições do IAM, é possível especificar quais clusters na frota podem acessar o bucket. Se nenhuma condição do IAM for especificada, todos os clusters na frota com a mesma conta de serviço do Kubernetes no mesmo namespace poderão acessar o bucket, o que representa um risco de integridade de identidade. Se você não especificar condições do IAM, também poderá usar o mecanismo de acesso legado que usa um segredo gerado com base na chave ativa de uma conta de serviço do Google. Confira um exemplo de como configurar e aplicar condições do IAM para limitar o acesso ao seu bucket:

  1. Crie o arquivo de condição do IAM:

    cat <<EOF > iam_condition.yaml
> expression: request.auth.claims.google.providerId == '$IDENTITY_PROVIDER'
title: allow_only_this_cluster
> EOF

  2. Aplique o arquivo de condições do IAM ao vincular a GSA à KSA. Execute o comando a seguir no projeto Google Cloud da GSA:

    gcloud iam service-accounts add-iam-policy-binding "${GSA_NAME}@${GSA_PROJECT_ID}.iam.gserviceaccount.com" \
  --project="${GSA_PROJECT_ID}" \
  --role=roles/iam.workloadIdentityUser \
  --member="serviceAccount:${WI_POOL}[${VM_NAMESPACE}/${KSA_NAME}]" \
  --condition-from-file=iam_condition.yaml

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://${BUCKET_PROJECT_ID}-vm-images/IMAGE_FILE_PATH
       serviceAccount: KSA_NAME
   size: DISK_SIZE
   storageClassName: robin-block-immediate

Substitua:

  • DISK_NAME: o nome do disco da máquina virtual.
  • NAMESPACE: o namespace da máquina virtual de destino.
  • IMAGE_FILE_PATH: o caminho completo e o nome do arquivo de imagem da máquina virtual. Clique com o botão direito do mouse na imagem no console do Google Cloud e selecione Copiar URI do gsutil para acessar esse caminho.
  • KSA_NAME: a conta de serviço do Kubernetes para baixar imagens de máquinas virtuais que você criou anteriormente.
  • DISK_SIZE: o tamanho do disco de destino. 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 armazenada em um serviço de terceiros

Você também pode usar http, https, S3 ou um registro de imagens para armazenar as imagens de máquina virtual. Se o serviço de armazenamento exigir credenciais para acesso, converta essas credenciais em um secret e especifique-o usando o campo secretRef. Exemplo:

source:
    http/s3/registry:
       url: 
       secretRef: "SECRET_NAME" # optional

Substitua SECRET_NAME pelo nome do seu secret.

Para mais informações, consulte Origem HTTP/S3/GCS/Registro.

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
  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

Se você ainda não tiver credenciais para acessar a máquina virtual, conclua as etapas desta seção para obtê-las 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: // enabled by default; disable with guestEnvironment: {}
   accessManagement:
    enable: 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