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:

Acesso ao GKE em um cluster Bare Metal versão 1.12.0 (anthosBareMetalVersion: 1.12.0) ou superior. Use qualquer tipo de cluster capaz de executar cargas de trabalho. Se necessário, teste o GKE em Bare Metal no Compute Engine ou consulte a visão geral da criação de clusters.
A ferramenta do cliente virtctl instalada como um plug-in para o kubectl. Se necessário, instale a ferramenta de cliente virtctl.

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:

Crie um manifesto de Network, como use-dhcp-network.yaml, no editor de sua escolha:
```
nano use-dhcp-network.yaml
```
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.
Salve e feche o manifesto Network no seu editor.
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:

Crie um manifesto de Network, como manual-network.yaml, no editor de sua escolha:
```
nano manual-network.yaml
```
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.
Salve e feche o manifesto Network no seu editor.
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:

Crie um manifesto de Network, como vlan-network.yaml, no editor de sua escolha:
```
nano vlan-network.yaml
```
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.
Salve e feche o manifesto Network no seu editor.
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:

Crie um manifesto de Network, como user-managed-network.yaml, no editor de sua escolha:
```
nano user-managed-network.yaml
```
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.
Salve e feche o manifesto Network no seu editor.

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.
Observação: no diretório ~/google-virtctl, um arquivo VM_NAME.yaml é criado. Consulte o conteúdo desse arquivo para conferir a definição dos recursos do Kubernetes que foram criados pelo ambiente de execução da VM no Google Distributed Cloud.

Manifesto

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

Crie um manifesto de VirtualMachine, como my-vm.yaml, no editor de sua escolha:
```
nano my-vm.yaml
```
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.
Salve e feche o manifesto VirtualMachine no seu editor.
Crie a VM usando kubectl:
```
kubectl apply -f my-vm.yaml
```

A seguir

Editar uma VM no GKE em Bare Metal