Gerenciar máquinas virtuais

Nesta página, descrevemos como gerenciar máquinas virtuais na sua implantação conectada do Google Distributed Cloud que executa o ambiente de execução de VM no Google Distributed Cloud. Você precisa 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 funcionam 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 entrar em contato com 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 -f LICENSE_FILE
   

   Substitua LICENSE_FILE pelo caminho para o arquivo de licença.

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
   

   Atenção: o parâmetro blocksize é obrigatório e precisa ser definido como o valor de 512.

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=v1.3.1-anthos1.35-gke.39
   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 -

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:

   • IDENTITY_PROVIDER: o provedor de identidade para este cluster.
   • WORKLOAD_IDENTITY_POOL: é o nome do pool de identidade da carga de trabalho associado à sua frota. O nome tem o formato FLEET_PROJECT_ID.svc.id.goog. Para mais informações sobre o comando desta etapa, consulte Usar a federação de identidade da carga de trabalho da frota em aplicativos.

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 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 omitidas, 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 fazer o download de imagens máquina virtual 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 destinados a ilustrar configurações para 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.

A alocação de recursos para VMs é limitada pelos perfis de hardware da sua implantação conectada do Distributed Cloud, como hardware G1 ou G2. Não é possível dimensionar uma única VM maior do que a máquina física conectada do Distributed Cloud em que ela é executada.

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 fez 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 desejados 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 e escolha uma configuração de máquina na lista suspensa Tipo de máquina. Em seguida, 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 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 a serem expostas externamente 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 Reiniciar automaticamente 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, especifique um valor secreto de dados do usuário no campo User data secret.

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 fez 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. Para detalhes sobre os campos YAML compatíveis, consulte a Referência de especificação de máquina virtual.

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. Para personalizar essa configuração, como as opções de CPU, memória ou rede, consulte a Referência de especificação da máquina virtual:

apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachine
metadata:
  name: my-virtual-machine
  namespace: NAMESPACE
spec:
  osType: Linux/Windows
  # guestEnvironment: {} # uncomment this line to disable guest environment
  priorityClassName: PRIORITY_CLASS
  compute:
    cpu:
      vcpus: 6
    memory:
      capacity: 8Gi
  interfaces:
    - name: eth0
      networkName: NETWORK_NAME
      ipAddresses:
        - IP_ADDRESS/PREFIX
  disks:
    - virtualMachineDiskName: DISK_NAME
      boot: true
    - virtualMachineDiskName: DISK_NAME

Substitua:

• NAMESPACE: o namespace de destino.
• PRIORITY_CLASS: a classe de prioridade para essa máquina virtual. Uma classe de prioridade é um intervalo de valores de prioridade. Use kubectl get priorityclass para ver uma lista de classes de prioridade compatíveis. Uma prioridade de programação mais alta reduz a chance de remoção da VM quando os recursos do nó estão limitados. Se omitido, a máquina virtual vai receber o valor padrão de prioridade mais baixa.
• NETWORK_NAME: o nome da rede L2 a que a interface da VM será anexada.
• DISK_NAME: os nomes dos discos da máquina virtual.
• vcpus: o número de vCPUs a serem atribuídas à VM.
• capacity: a quantidade de memória a ser atribuída à VM. Por exemplo, 4Gi ou 8Gi.
• ipAddresses: opcional; fornece atribuição de IP estático para a máquina virtual. Se a rede L2 subjacente oferecer suporte ao DHCP externo, omita ipAddresses para permitir a alocação dinâmica.

Usar a API cloud-init para inicializar VMs

A API cloud-init é uma maneira padrão de inicializar uma VM na nuvem. Use cloud-init para configurar arquivos, usuários e outros aspectos da sua VM.

Para garantir a compatibilidade, valide as rotinas de inicialização do cloud-init. Antes de usar a configuração em produção, aplique-a a uma VM de teste para garantir que ela seja inicializada corretamente.

Os exemplos a seguir são genéricos e precisam ser testados no seu ambiente.

Automatizar a configuração de VM com dados do usuário cloud-init

O ambiente de execução de VM no GDC é compatível com dados do usuário cloud-init para VMs Linux. É possível especificar dados do usuário como uma string de texto simples, uma string codificada em base64 ou referenciando um secret do Kubernetes.

Para garantir que a VM seja inicializada corretamente, valide todas as configurações de dados do usuário antes de implantá-las em um ambiente de produção.

O exemplo a seguir mostra um manifesto VirtualMachine que inclui dados do usuário cloud-init em texto simples para executar um comando quando a VM é inicializada:

apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachine
metadata:
  name: VM_NAME
spec:
  compute:
    cpu:
      vcpus: 2
    memory:
      capacity: 4Gi
  osType: Linux
  cloudInit:
    noCloud:
      userData: |
        #cloud-config
        runcmd:
          - echo "Hello World" > /tmp/hello.txt

Substitua VM_NAME pelo nome da máquina virtual.

Para criar a VM com dados de cloud-init, salve o manifesto como vm-cloud-init.yaml e aplique-o ao cluster executando o comando kubectl apply:

kubectl apply -f vm-cloud-init.yaml

Resolver problemas da cloud-init

Se você encontrar problemas com cloud-init, verifique os registros na VM. Normalmente, é possível encontrar os registros nos seguintes diretórios:

• /var/log/cloud-init.log
• /var/log/cloud-init-output.log

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

É possível criar uma máquina virtual (VM) do Windows que é inicializada de uma imagem ISO usando o ambiente de execução de VMs no GDC. Com esse recurso, é possível migrar aplicativos empresariais legados baseados no Windows, softwares especializados de terceiros ou sistemas de ponto de venda personalizados diretamente para os clusters conectados do Distributed Cloud.

As imagens usadas para discos de VM são importadas de um bucket de imagens conectado do Distributed Cloud. Antes de criar os manifestos, faça o download da ISO de instalação do Windows e da ISO de drivers do KubeVirt virtio e envie para o bucket de imagens. Recomendamos que você mantenha uma cópia verificada do ISO dos drivers em um repositório interno ou faça o pré-staging no Cloud Storage para garantir builds de máquina virtual confiáveis e repetíveis.

Criar os manifestos

Para inicializar com uma imagem ISO do Windows, você precisa dos seguintes manifestos:

• Um VirtualMachineDisk que contém o ISO do Windows.
• Um VirtualMachineDisk que contém os drivers virtio do Windows do KubeVirt.
• Um VirtualMachineDisk vazio para servir como disco de inicialização em que o Windows será instalado.

Os exemplos a seguir mostram os manifestos VirtualMachineDisk para os três discos necessários.

Nos manifestos, substitua o seguinte:

• BUCKET_PROJECT_ID: o ID do projeto em que o bucket de imagens está localizado.
• KSA_NAME: a conta de serviço do Kubernetes com permissões para ler do bucket.

O PVC size solicitado nos manifestos precisa ser sempre maior ou igual ao tamanho virtual exato da ISO.

Disco ISO do Windows

apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineDisk
metadata:
  name: windows-iso
spec:
  size: 10Gi
  storageClassName: robin-block-immediate
  diskType: cdrom
  source:
    gcs:
      url: gs://BUCKET_PROJECT_ID-vm-images/windows.iso
      serviceAccount: KSA_NAME

Disco de drivers VirtIO

apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineDisk
metadata:
  name: virtio-driver
spec:
  size: 1Gi
  storageClassName: robin-block-immediate
  diskType: cdrom
  source:
    gcs:
      url: gs://BUCKET_PROJECT_ID-vm-images/virtio-win.iso
      serviceAccount: KSA_NAME

Disco de inicialização vazio

apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineDisk
metadata:
  name: windows-vm-boot-dv
spec:
  size: 40Gi
  storageClassName: robin-block-immediate

Criar os discos

Para criar esses discos, salve os manifestos VirtualMachineDisk e aplique-os ao cluster executando o comando kubectl apply:

kubectl apply -f windows-iso.yaml
kubectl apply -f virtio-driver.yaml
kubectl apply -f windows-vm-boot-dv.yaml

Criar uma VM do Windows

Para criar uma VM do Windows, crie um manifesto que defina a VM e referencie os discos. A VM é inicializada do disco ISO para iniciar a instalação.

O exemplo a seguir mostra um manifesto de VirtualMachine:

apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachine
metadata:
  labels:
    kubevirt.io/vm: windows-vm
  name: windows-vm
spec:
  osType: Windows
  disks:
    - virtualMachineDiskName: windows-vm-boot-dv
      boot: true
    - virtualMachineDiskName: windows-iso
    - virtualMachineDiskName: virtio-driver
  compute:
    cpu:
      vcpus: 2
    memory:
      capacity: 4Gi
  interfaces:
    - name: eth0
      networkName: NETWORK_NAME
      default: true
      ipAddresses:
        - IP_ADDRESS/PREFIX

Observação: o campo ipAddresses fornece atribuição de IP estático. Se a rede L2 subjacente for compatível com DHCP externo, omita ipAddresses para permitir a alocação dinâmica.

Para criar a VM, salve o manifesto como windows-vm.yaml e aplique-o ao cluster executando o comando kubectl apply:

kubectl apply -f windows-vm.yaml

Conectar e concluir a instalação

Para conectar e concluir a instalação, siga estas etapas:

1. Para se conectar à VM usando o VNC, use a ferramenta virtctl ou o plug-in kubectl virt:

   virtctl vnc windows-vm
   

   Ou, se você instalou o virtctl como um plug-in kubectl:

   kubectl virt vnc windows-vm
   

   Para mais informações sobre virtctl, consulte a documentação do KubeVirt.

2. Siga as instruções mostradas pelo instalador do Windows. Quando solicitado, selecione Instalação personalizada.

3. Quando solicitado, carregue os drivers virtio para armazenamento e rede, navegando até o disco virtio-driver anexado.

4. Conclua a instalação.

Acesso pelo protocolo de área de trabalho remota

Depois de instalar e ativar o protocolo Remote Desktop (RDP) no SO convidado, você pode acessar a VM pelo RDP.

Como a máquina virtual está anexada a uma rede L2, ela pode ser acessada diretamente de fora do cluster usando o endereço IP atribuído (por exemplo, 10.223.237.10). Conecte-se a esse endereço IP na porta 3389 usando um cliente RDP. Verifique se o endereço IP interno da camada 2 pode ser acessado da máquina cliente pelo firewall corporativo e pelas regras de roteamento.

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.

Referência de especificação da máquina virtual

A tabela a seguir descreve os campos principais na especificação VirtualMachine. Use esses campos ao configurar um manifesto YAML de máquina virtual para aplicar ao cluster usando kubectl apply ou ao usar a opção Criar com YAML no console Google Cloud .

Campo	Descrição	Obrigatório
apiVersion	Precisa ser vm.cluster.gke.io/v1.	Obrigatório
kind	Precisa ser VirtualMachine.	Obrigatório
metadata.name	Um nome exclusivo para a máquina virtual.	Obrigatório
metadata.namespace	O namespace do Kubernetes em que a VM é executada.	Obrigatório
spec.osType	O tipo de sistema operacional convidado. Valores aceitos: Linux e Windows.	Obrigatório
spec.guestEnvironment	Configura o ambiente de convidado. Se omitido, o ambiente de convidado será ativado por padrão. Para desativar, defina como {}.	Opcional
spec.priorityClassName	A classe de prioridade da VM. Uma prioridade mais alta reduz a chance de remoção.	Opcional
spec.compute	Configura os recursos de computação da VM.	Obrigatório
spec.compute.cpu.vcpus	Número de vCPUs a serem alocadas. Os valores aceitos são de 1 a 96.	Obrigatório
spec.compute.memory.capacity	Capacidade de memória, por exemplo, 8Gi.	Obrigatório
spec.interfaces	Lista de interfaces de rede da VM.	Obrigatório
spec.interfaces[].name	Nome da interface, por exemplo, eth0.	Obrigatório
spec.interfaces[].networkName	Nome da sub-rede a ser conectada, que é mapeada para um recurso Network no cluster.	Obrigatório
spec.interfaces[].ipAddresses	Endereços IP estáticos a serem atribuídos a essa interface. Se a sub-rede não tiver o DHCP ativado, especifique um endereço IP estático.	Opcional
spec.disks	Lista de discos a serem anexados à VM.	Obrigatório
spec.disks[].virtualMachineDiskName	Nome do recurso VirtualMachineDisk.	Obrigatório
spec.disks[].boot	Defina como true para o disco de inicialização. Apenas um disco pode ser marcado como inicializável.	Opcional

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.

Requisitos de rede para acesso direto

Para acessar uma máquina virtual diretamente da sua rede local sem usar um serviço LoadBalancer do Kubernetes, configure os componentes de rede lógicos e físicos. O Distributed Cloud Connected gerencia automaticamente os recursos de rede no cluster, mas é necessário configurar a rede externa e a interface da VM.

1. Configurar sub-rede (VLAN): crie uma sub-rede com um ID de VLAN específico usando a API Distributed Cloud Edge Network, gcloud ou a API. O Distributed Cloud Connected sincroniza automaticamente essa configuração com o cluster. Não é necessário criar recursos de rede do Kubernetes manualmente. Consulte Criar e gerenciar sub-redes.

2. Configure sua rede local: o administrador da rede precisa configurar os switches e roteadores físicos conectados aos servidores conectados do Distributed Cloud para:

   • Permita o ID da VLAN configurado nas portas do switch (entroncamento da VLAN).
   • Ative o roteamento entre sua rede local e a sub-rede. Se o protocolo de gateway de borda (BGP), um protocolo de roteamento dinâmico, estiver configurado nos roteadores conectados do Distributed Cloud, essas rotas serão anunciadas automaticamente após a criação da sub-rede. Caso contrário, configure rotas estáticas nos roteadores físicos para rotear o tráfego do intervalo IP (CIDR) da sub-rede para os nós conectados do Distributed Cloud.

3. Configurar a interface da VM: na configuração YAML VirtualMachine, configure a VM para usar essa sub-rede especificando o nome da rede no campo spec.interfaces. Para mais informações, consulte Referência de especificação de máquina virtual.

Receber credenciais de acesso para VMs do Linux

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 que contenha 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.

4. Para verificar o status da solicitação de acesso, execute o comando kubectl get:

   kubectl get vmar
   

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

5. Acesse a máquina virtual com SSH. Se a máquina virtual estiver conectada à rede local, acesse-a diretamente usando SSH:

   ssh USERNAME@VM_IP_ADDRESS -i PATH_TO_KEY

   Substitua:

   • USERNAME: o nome de usuário para fazer login, por exemplo, o usuário configurado no recurso VirtualMachineAccessRequest.
   • VM_IP_ADDRESS: o endereço IP da sua máquina virtual.
   • PATH_TO_KEY: o caminho para a chave privada SSH correspondente à chave pública gerada nas etapas anteriores.

Usar o RDP para acessar uma VM do Windows

Para acessar uma VM do Windows usando o protocolo da área de trabalho remota (RDP) da sua rede local, ative o RDP no SO convidado, verifique se a VM pode ser acessada pela rede e configure as credenciais do usuário.

Pré-requisitos

Ativar o RDP no Windows: o RDP precisa ser ativado no SO convidado do Windows. Se o RDP ainda não estiver ativado, use um console de computação de rede virtual (VNC) para acessar a tela da VM diretamente e ativá-lo. O comando kubectl virt vnc abre uma janela de visualização gráfica na estação de trabalho local e exige um cliente visualizador de VNC, como o Remote Viewer ou o VNC Viewer, instalado na estação de trabalho:

kubectl virt vnc VM_NAME -n NAMESPACE

Substitua:

• VM_NAME: o nome da VM do Windows.
• NAMESPACE: o namespace da VM.

Conectar usando o RDP

1. Para saber o endereço IP da VM, execute o comando kubectl get:

   kubectl get vmi VM_NAME -n NAMESPACE -o jsonpath='{.status.interfaces[*].ipAddress}'

   Substitua:

   • VM_NAME: o nome da VM do Windows.
   • NAMESPACE: o namespace da VM.

   Anote o endereço IP da sub-rede roteada na saída.

2. Use um cliente RDP padrão, como a Conexão de área de trabalho remota no Windows ou o Remmina no Linux, para se conectar ao endereço IP recuperado na porta 3389.

3. Use o nome de usuário e a senha para fazer login.

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 fez 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 fez 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, é preciso 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 fez 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 que aparecer, insira o nome da máquina virtual e clique em EXCLUIR.

A seguir

• Implantar cargas de trabalho no Distributed Cloud conectado
• Gerenciar cargas de trabalho de GPU
• Gerenciar zonas
• Gerenciar máquinas
• Gerenciar clusters
• Gerenciar pools de nós