Criar e usar redes virtuais do ambiente de execução da VM no Google Distributed Cloud

Este documento é destinado a proprietários de aplicativos e administradores de plataforma que executam o GKE em Bare Metal. Neste documento, mostramos como criar e usar redes virtuais para dar suporte a cargas de trabalho de VM que usam o ambiente de execução da VM no Google Distributed Cloud.

Antes de começar

Para concluir este documento, você precisa de acesso aos seguintes recursos:

Visão geral das redes virtuais

As redes são criadas usando recursos personalizados. É possível criar uma rede a qualquer momento depois que o cluster for criado. As configurações de rede da interface do host e da atribuição de ID da VLAN, se definidas, não podem ser alteradas depois que você cria uma rede.

A exclusão de redes está sujeita a algumas condições. Por exemplo, o controlador de rede rejeita a exclusão de uma rede quando ela está em uso por qualquer recurso, como VMs ou interfaces de rede.

A definição da rede pode incluir o gateway, os trajetos e as informações do DNS. Também é possível ativar o uso de um servidor DHCP externo. Essas configurações de rede são atribuídas de maneira estática ou dinâmica, dependendo de como determinadas opções de configuração de rede são definidas.

Rede-pod padrão

Cada cluster tem um pod-network criado por padrão. Não é possível mudar essa rede. As rotas para CIDR de pod e CIDR de serviço e configuração de DNS são preenchidas automaticamente. A configuração de DNS usa os mesmos valores que o cluster.

O pod-network pode ser usado por cargas de trabalho que precisam de uma interface para acessar a rede de pods do cluster e que não precisam de nenhuma opção de configuração específica. As rotas do pod-network são sempre configuradas para garantir que o cluster e o acesso do serviço às cargas de trabalho, mesmo que o gateway padrão não esteja na interface pod-network.

Com o pod-network padrão, é possível testar o ambiente de execução da VM no Google Distributed Cloud sem precisar realizar outras etapas para criar suas próprias redes virtuais. Muitos dos nossos documentos usam esse pod-network padrão para reduzir a complexidade dos exemplos. As necessidades das cargas de trabalho da VM determinam se esse pod-network padrão é suficiente ou se você precisa criar e usar as próprias redes virtuais.

O manifesto YAML a seguir mostra uma configuração de amostra de pod-network. Os valores de rotas, DNS e nome da interface foram preenchidos pelo cluster:

  ​​apiVersion: networking.gke.io/v1
  kind: Network
  metadata:
    name: pod-network
  spec:
    routes:
    - to: 192.168.0.0/16
    - to: 10.96.0.0/12
    dnsConfig:
      nameservers:
      - 10.96.0.10

Criar e usar redes virtuais

Para oferecer suporte a cargas de trabalho de produção, crie redes compatíveis com os recursos necessários, como o uso de um servidor DHCP externo ou um ID da VLAN. Essas redes fornecem conectividade de camada 2 (L2) para suas VMs.

Usar um servidor DHCP externo

O ambiente de execução da VM no Google Distributed Cloud não fornece servidores DHCP. Você precisa especificar manualmente os endereços IP para VMs ou configurar o uso de servidores DHCP externos. Ao ativar o uso de um servidor DHCP externo, é possível pular as configurações de DNS e gateway se elas são fornecidas pelo DHCP.

Para criar uma rede que usa um servidor DHCP externo, siga as etapas a seguir:

  1. Crie um manifesto de Network, como use-dhcp-network.yaml, no editor de sua escolha:

    nano use-dhcp-network.yaml
    
  2. Copie e cole o seguinte manifesto YAML:

    apiVersion: networking.gke.io/v1
    kind: Network
    metadata:
      name: NETWORK_NAME
    spec:
      type: L2
      nodeInterfaceMatcher:
        interfaceName: INTERFACE_NAME
      externalDHCP4: true
    

    Substitua os seguintes valores:

    • NETWORK_NAME: o nome da sua rede.
    • INTERFACE_NAME: o nome da interface no nó do GKE em Bare Metal para anexar a rede. Especifique o nome da interface física no nó a ser usado. Todos os nós do cluster precisam ter o mesmo nome de interface.

    Nesse manifesto Network, os seguintes valores são definidos:

    • type, definida como L2. Com essa configuração, as cargas de trabalho só podem ter um anexo de camada 2 nesta rede. Essa é a única rede type que pode ser criada no ambiente de execução da VM no Google Distributed Cloud.
    • externalDHCP4, definida como true. Essa configuração ativa o DHCP externo para a rede. O servidor DHCP externo é responsável pela configuração de alocação de endereços IPv4, rotas, gateway e DNS para cargas de trabalho conectadas a essa rede.
  3. Salve e feche o manifesto Network no seu editor.

  4. Crie a rede usando kubectl:

    kubectl apply -f use-dhcp-network.yaml
    

Definir manualmente as configurações de rede

O ambiente de execução da VM no Google Distributed Cloud não fornece servidores DHCP. Você precisa especificar manualmente os endereços IP para VMs ou configurar o uso de servidores DHCP externos. Se você especificar manualmente os endereços IP, será necessário definir as configurações de rede para DNS, rotas e gateway padrão.

Para criar uma rede com configurações de rede especificadas manualmente para VMs, siga estas etapas:

  1. Crie um manifesto de Network, como manual-network.yaml, no editor de sua escolha:

    nano manual-network.yaml
    
  2. Copie e cole o seguinte manifesto YAML:

    apiVersion: networking.gke.io/v1
    kind: Network
    metadata:
      name: NETWORK_NAME
    spec:
      type: L2
      nodeInterfaceMatcher:
        interfaceName: INTERFACE_NAME
      routes:
      - to: "ROUTE_ADDRESS"
      gateway4: GATEWAY_ADDRESS
      dnsConfig:
        nameservers:
        - NAMESERVER_ADDRESS
    

    Substitua os seguintes valores:

    • NETWORK_NAME: o nome da sua rede.
    • INTERFACE_NAME: o nome da interface no nó do GKE em Bare Metal para anexar a rede. Especifique o nome da interface física no nó a ser usado. Todos os nós do cluster precisam ter o mesmo nome de interface.
    • ROUTE_ADDRESS: rotas opcionais na notação CIDR para configurar em cada VM que se conecta a essa rede.
    • GATEWAY_ADDRESS: o endereço IP do gateway que suas VMs usarão.
    • NAMESERVER_ADDRESS: um ou mais endereços IP de servidor de nomes DNS para as VMs usarem.
  3. Salve e feche o manifesto Network no seu editor.

  4. Crie a rede usando kubectl:

    kubectl apply -f manual-network.yaml
    

Usar um ID da VLAN

Ao criar redes virtuais, é possível definir VLANs com tags. Essas atribuições de VLAN ajudam a isolar o tráfego de rede com base nos requisitos da carga de trabalho e nas necessidades de isolamento. Em uma rede AnthosManaged, o cluster tem permissão para criar e excluir a interface da VLAN em cada nó.

Para criar uma rede que defina uma atribuição de VLAN, conclua as seguintes etapas:

  1. Crie um manifesto de Network, como vlan-network.yaml, no editor de sua escolha:

    nano vlan-network.yaml
    
  2. Copie e cole o seguinte manifesto YAML:

    apiVersion: networking.gke.io/v1
    kind: Network
    metadata:
      name: NETWORK_NAME
    spec:
      type: L2
      networkLifecycle: AnthosManaged
      l2NetworkConfig:
        vlanID: VLAN_ID
      nodeInterfaceMatcher:
        interfaceName: INTERFACE_NAME
      externalDHCP4: true
    

    Substitua os seguintes valores:

    • NETWORK_NAME: o nome da sua rede.
    • INTERFACE_NAME: o nome da interface no nó do GKE em Bare Metal para anexar a rede. Especifique o nome da interface física no nó a ser usado. Todos os nós do cluster precisam ter o mesmo nome de interface.
    • VLAN_ID: o ID da VLAN para o qual você quer marcar o tráfego.

    Nesse manifesto Network, os seguintes valores são definidos:

    • As cargas de trabalho podem ter apenas um anexo L2 para esta rede.
    • A rede é AnthosManaged. Essa configuração é o ciclo de vida padrão, se não for especificada.
      • Nesse modo, o cluster tem permissão para criar e excluir a interface da VLAN em cada nó, como INTERFACE_NAME.VLAN_ID.
      • Se você quiser criar ou já tiver criado as interfaces da VLAN nos nós, defina o valor networkLifecycle como UserManaged, conforme mostrado na próxima seção.
    • O DHCP externo está ativado na rede. O servidor DHCP externo é responsável pela configuração de alocação de endereços IPv4, rotas, gateway e DNS para cargas de trabalho conectadas a essa rede.
  3. Salve e feche o manifesto Network no seu editor.

  4. Crie a rede usando kubectl:

    kubectl apply -f vlan-network.yaml
    

Criar uma rede gerenciada pelo usuário

No exemplo de rede virtual a seguir, a rede é gerenciada pelo usuário, em vez de gerenciada pelo Anthos em um exemplo anterior. Em redes gerenciadas pelo usuário, você é responsável por criar ou excluir a interface da VLAN no host.

Para criar uma rede em modo gerenciado pelo usuário e definir manualmente a configuração da interface da VLAN, siga estas etapas:

  1. Crie um manifesto de Network, como user-managed-network.yaml, no editor de sua escolha:

    nano user-managed-network.yaml
    
  2. Copie e cole a seguinte definição de YAML:

    apiVersion: networking.gke.io/v1
    kind: Network
    metadata:
      name: NETWORK_NAME
    spec:
      type: L2
      networkLifecycle: UserManaged
      l2NetworkConfig:
        vlanID: VLAN_ID
      nodeInterfaceMatcher:
        interfaceName: INTERFACE_NAME
      externalDHCP4: true
    

    Substitua os seguintes valores:

    • NETWORK_NAME: o nome da sua rede.
    • INTERFACE_NAME: a interface do host a que a rede será anexada.
    • VLAN_ID: o ID da VLAN para o qual você quer marcar o tráfego.

    Nesse manifesto Network, os seguintes valores são definidos:

    • As cargas de trabalho podem ter apenas um anexo L2 para esta rede.
    • A rede é UserManaged. Crie ou exclua a interface VLAN_ID da VLAN em cada nó antes da criação da rede ou depois que a rede for excluída.
    • O DHCP externo está ativado na rede. O servidor DHCP externo é responsável pela configuração de alocação de endereços IPv4, rotas, gateway e DNS para cargas de trabalho conectadas a essa rede.
  3. Salve e feche o manifesto Network no seu editor.

  4. Crie a rede usando kubectl:

    kubectl apply -f user-managed-network.yaml
    

Conectar uma VM a uma rede

As configurações de rede da VM, como DNS e DHCP, são atribuídas de maneira estática ou dinâmica, dependendo de como algumas opções de configuração de rede estão definidas:

  • Se você configurar um endereço IP estático na VM, nenhuma consulta será enviada para um servidor DHCP. As informações adicionais para configurar o gateway e a rota precisam vir do recurso de rede.
  • Se você não configurar um endereço IP estático na VM, uma consulta será enviada ao servidor DHCP. A VM recebe todas as informações do servidor DHCP e ignora qualquer configuração definida no recurso de rede.
  • Se o DHCP externo não estiver definido como true no recurso de rede, será preciso configurar um endereço IP estático para a VM. Todas as outras informações são provenientes da configuração definida no recurso de rede.

Para criar uma VM que se conecta a uma rede, siga estas etapas:

CLI

  • Para criar uma VM usando kubectl, conclua as seguintes etapas:

    kubectl virt create vm VM_NAME \
      --image ubuntu20.04 \
      --network NETWORK_NAME
    

    Substitua os seguintes valores:

    • VM_NAME: o nome da VM.
    • NETWORK_NAME: o nome da rede a ser conectada.
      • Se a rede estiver configurada para permitir o uso de servidores DHCP externos, a VM receberá uma atribuição de endereço IP automaticamente. Se você precisar definir um endereço IP estático, adicione o valor e o parâmetro --ip IP_ADDRESS opcionais.

Manifesto

Para criar uma VM usando um manifesto YAML, siga estas etapas:

  1. Crie um manifesto de VirtualMachine, como my-vm.yaml, no editor de sua escolha:

    nano my-vm.yaml
    
  2. Copie e cole o seguinte manifesto YAML:

    apiVersion: vm.cluster.gke.io/v1
    kind: VirtualMachine
    metadata:
      name: VM_NAME
    spec:
      interfaces:
        - name: eth0
          networkName: NETWORK_NAME
          ipAddresses:
            - IP_ADDRESS
          default: true
      disks:
        - virtualMachineDiskName: VM_NAME-boot-dv
          boot: true
    

    Nesse manifesto YAML, defina as seguintes configurações:

    • VM_NAME: o nome da VM.
    • NETWORK_NAME: o nome da rede a ser conectada.
    • IP_ADDRESS: o endereço IP na notação CIDR para atribuir à VM, como 192.0.2.10/24.
      • Se a rede estiver configurada para permitir o uso de servidores DHCP externos, remova este campo do manifesto VirtualMachine.

    O disco de inicialização chamado VM_NAME-boot-dv já precisa existir. Para mais informações, consulte Criar um disco de inicialização de VM.

  3. Salve e feche o manifesto VirtualMachine no seu editor.

  4. Crie a VM usando kubectl:

    kubectl apply -f my-vm.yaml
    

A seguir