Esta página foi traduzida pela API Cloud Translation.

Crie e use redes virtuais para o VM Runtime no GDC

Este documento destina-se a administradores de TI, operadores e especialistas em rede que executam o Google Distributed Cloud. Este documento mostra como criar e usar redes virtuais para suportar cargas de trabalho de VMs que usam o VM Runtime no GDC. Para saber mais sobre as funções comuns e exemplos de tarefas que referimos no conteúdo, consulte o artigo Funções e tarefas comuns do utilizador do GKE. Google Cloud

Antes de começar

Para preencher este documento, precisa de ter acesso aos seguintes recursos:

Acesso à versão 1.12.0 do Google Distributed Cloud (anthosBareMetalVersion: 1.12.0) ou a um cluster superior. Pode usar qualquer tipo de cluster capaz de executar cargas de trabalho. Se necessário, experimente o Google Distributed Cloud no Compute Engine ou consulte a vista geral da criação de clusters.
A ferramenta de cliente virtctl instalada como um plug-in para o kubectl. Se necessário, instale a ferramenta de cliente virtctl.

Vista geral das redes virtuais

As redes são criadas com recursos personalizados. Pode criar uma rede em qualquer altura após a criação do cluster. Não é possível alterar as definições de rede da interface do anfitrião e a atribuição do ID da VLAN, se estiver definida, depois de criar uma rede.

A eliminação de redes está sujeita a algumas condições. Por exemplo, o controlador de rede rejeita a eliminação de uma rede quando está a ser usada por quaisquer recursos, como VMs ou interfaces de rede.

A definição da rede pode incluir o gateway, os trajetos e as informações de DNS. Também pode ativar a utilização de um servidor DHCP externo. Estas definições de rede são atribuídas estática ou dinamicamente, consoante a forma como determinadas opções de configuração de rede são definidas.

Default pod-network

Cada cluster tem um pod-network criado por predefinição para si. Não é possível alterar esta rede. As rotas para o CIDR do pod e o CIDR do serviço, bem como a 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 aceder à rede de pods do cluster e não precisam de opções de configuração específicas. As rotas do pod-network estão sempre configuradas para garantir o acesso do cluster e do serviço para as cargas de trabalho, mesmo que o gateway predefinido não esteja na interface pod-network.

Esta pod-network predefinição permite-lhe testar o tempo de execução da VM no GDC sem passos adicionais para criar as suas próprias redes virtuais. Muitos dos nossos documentos usam este pod-network predefinido para reduzir a complexidade dos exemplos. As necessidades das suas cargas de trabalho de VMs determinam se esta predefinição pod-network é suficiente ou se precisa de criar e usar as suas próprias redes virtuais.

predefinido.

O manifesto YAML seguinte mostra uma configuração de exemplo para o pod-network. Os valores para rotas, DNS e o 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

Crie e use redes virtuais

Para suportar cargas de trabalho de produção, crie redes que suportem as funcionalidades de que precisa, como a utilização de um servidor DHCP externo ou a utilização de um ID de VLAN. Estas redes fornecem conetividade de camada 2 (L2) para as suas VMs.

Use um servidor DHCP externo

O tempo de execução de VMs no GDC não fornece servidores DHCP. Tem de especificar manualmente os endereços IP para as VMs ou configurar a utilização de servidores DHCP externos. Quando ativa a utilização de um servidor DHCP externo, pode ignorar a configuração das definições de DNS e gateway se forem fornecidas pelo DHCP.

Para criar uma rede que use um servidor DHCP externo, conclua os seguintes passos:

Crie um manifesto Network, como use-dhcp-network.yaml, no editor da 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 seu nó do Google Distributed Cloud ao qual anexar a rede. Especifique o nome da interface física no seu nó a usar. Todos os nós no cluster devem ter o mesmo nome de interface.
Neste manifesto Network, são definidos os seguintes valores:
- A definição de type é L2. Com esta definição, as cargas de trabalho só podem ter uma ligação de camada 2 a esta rede. Esta é a única rede type que pode criar no VM Runtime no GDC.
- A definição de externalDHCP4 é true. Esta definição ativa o DHCP externo para a rede. O servidor DHCP externo é responsável pela atribuição de endereços IPv4, pelas rotas, pelo gateway e pela configuração de DNS para cargas de trabalho ligadas a esta rede.
Guarde e feche o manifesto Network no editor.
Crie a rede com kubectl:
```
kubectl apply -f use-dhcp-network.yaml
```

Defina manualmente as definições de rede

O tempo de execução de VMs no GDC não fornece servidores DHCP. Tem de especificar manualmente os endereços IP para as VMs ou configurar a utilização de servidores DHCP externos. Se especificar manualmente os endereços IP, tem de definir as definições de rede para DNS, rotas e gateway predefinido.

Para criar uma rede com definições de rede especificadas manualmente para VMs, conclua os seguintes passos:

Crie um manifesto Network, como manual-network.yaml, no editor à 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 seu nó do Google Distributed Cloud ao qual anexar a rede. Especifique o nome da interface física no seu nó a usar. Todos os nós no cluster devem ter o mesmo nome de interface.
- ROUTE_ADDRESS: rotas opcionais na notação CIDR para configurar em todas as VMs que se ligam a esta rede.
- GATEWAY_ADDRESS: o endereço IP do gateway que as suas VMs vão usar.
- NAMESERVER_ADDRESS: um ou mais endereços IP do servidor de nomes DNS para as suas VMs usarem.
Guarde e feche o manifesto Network no editor.
Crie a rede com kubectl:
```
kubectl apply -f manual-network.yaml
```

Use um ID de VLAN

Quando cria redes virtuais, pode definir VLANs etiquetadas. Estas 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. Numa rede AnthosManaged, o cluster tem autorização para criar e eliminar a interface VLAN em todos os nós.

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

Crie um manifesto Network, como vlan-network.yaml, no editor à 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 seu nó do Google Distributed Cloud ao qual anexar a rede. Especifique o nome da interface física no seu nó a usar. Todos os nós no cluster devem ter o mesmo nome de interface.
- VLAN_ID: o ID da VLAN para o qual quer etiquetar o tráfego.
Neste manifesto Network, são definidos os seguintes valores:
- As cargas de trabalho só podem ter uma associação L2 a esta rede.
- A rede é AnthosManaged. Esta é a predefinição do ciclo de vida se não for especificada.
  - Neste modo, o cluster tem autorização para criar e eliminar a interface VLAN em todos os nós, como INTERFACE_NAME.VLAN_ID.
  - Se quiser criar, ou já tiver criado, as interfaces de VLAN nos nós, defina o valor networkLifecycle como UserManaged, conforme mostrado na secção seguinte.
- A rede tem o DHCP externo ativado. O servidor DHCP externo é responsável pela atribuição de endereços IPv4, rotas, gateway e configuração de DNS para cargas de trabalho ligadas a esta rede.
Guarde e feche o manifesto Network no editor.
Crie a rede com kubectl:
```
kubectl apply -f vlan-network.yaml
```

Crie uma rede gerida pelo utilizador

Na rede virtual do exemplo seguinte, a rede é gerida pelo utilizador, ao contrário da rede gerida pelo Anthos num exemplo anterior. Nas redes geridas pelo utilizador, é responsável por criar ou eliminar a interface VLAN no anfitrião.

Para criar uma rede num modo gerido pelo utilizador e definir manualmente a configuração da interface VLAN, conclua os seguintes passos:

Crie um manifesto Network, como user-managed-network.yaml, no editor à sua escolha:
```
nano user-managed-network.yaml
```
Copie e cole a seguinte definição 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 anfitrião à qual anexar a rede.
- VLAN_ID: o ID da VLAN para o qual quer etiquetar o tráfego.
Neste manifesto Network, são definidos os seguintes valores:
- As cargas de trabalho só podem ter uma associação L2 a esta rede.
- A rede é UserManaged. Tem de criar ou eliminar a interface VLAN VLAN_ID em todos os nós antes de criar a rede ou depois de a eliminar.
- A rede tem o DHCP externo ativado. O servidor DHCP externo é responsável pela atribuição de endereços IPv4, rotas, gateway e configuração de DNS para cargas de trabalho ligadas a esta rede.
Guarde e feche o manifesto Network no editor.

Crie a rede com kubectl:

kubectl apply -f user-managed-network.yaml

Ligue uma VM a uma rede

As definições de rede da sua VM, como DNS e DHCP, são atribuídas estática ou dinamicamente, consoante a forma como são definidas determinadas opções de configuração de rede:

Se configurar um endereço IP estático na VM, não é enviada nenhuma consulta para um servidor DHCP. As informações adicionais para configurar o gateway e a rota têm de vir do recurso de rede.
Se não configurar um endereço IP estático na VM, é enviada uma consulta para o servidor DHCP. A VM recebe todas as informações do servidor DHCP e ignora qualquer configuração que defina no recurso de rede.
Se o DHCP externo não estiver definido como true no recurso de rede, tem de configurar um endereço IP estático para a VM. Todas as outras informações provêm da configuração que define no recurso de rede.

Para criar uma VM que se ligue a uma rede, conclua os seguintes passos:

CLI

Para criar uma VM com o kubectl, conclua os seguintes passos:
```
kubectl virt create vm VM_NAME \
  --image ubuntu20.04 \
  --network NETWORK_NAME
```
Substitua os seguintes valores:
- VM_NAME: o nome da sua VM.
- NETWORK_NAME: o nome da sua rede à qual se ligar.
  - Se a rede estiver configurada para permitir a utilização de servidores DHCP externos, a VM recebe uma atribuição de endereço IP automaticamente. Se precisar de definir um endereço IP estático, adicione o parâmetro --ip IP_ADDRESS opcional e o valor.
Nota: no diretório ~/google-virtctl, é criado um ficheiro VM_NAME.yaml. Pode ver o conteúdo deste ficheiro para ver a definição dos recursos do Kubernetes que foram criados pelo VM Runtime no GDC.

Manifesto

Para criar uma VM com um manifesto YAML, conclua os seguintes passos:

Crie um manifesto VirtualMachine, como my-vm.yaml, no editor à 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
```
Neste manifesto YAML, defina as seguintes definições:
- VM_NAME: o nome da sua VM.
- NETWORK_NAME: o nome da sua rede à qual se ligar.
- IP_ADDRESS: o endereço IP na notação CIDR a atribuir à sua VM, como 192.0.2.10/24.
  - Se a sua rede estiver configurada para permitir a utilização de servidores DHCP externos, remova este campo do manifesto VirtualMachine.
O disco de arranque com o nome VM_NAME-boot-dv já tem de existir. Para mais informações, consulte o artigo Crie um disco de arranque de VM.
Guarde e feche o manifesto VirtualMachine no editor.
Crie a VM com kubectl:
```
kubectl apply -f my-vm.yaml
```

O que se segue?

Edite uma VM no Google Distributed Cloud.