Nesta página, mostramos como ativar várias interfaces em nós e pods em um cluster do Google Kubernetes Engine (GKE) usando o suporte a várias redes para pods. O suporte a várias redes está disponível apenas para projetos ativados com o GKE Enterprise.
Partimos do pressuposto de que você conhece os conceitos gerais de rede, a terminologia e os conceitos específicos desse recurso e os requisitos e limitações para compatibilidade com várias redes nos pods.
Para mais informações, consulte Sobre o suporte a várias redes para pods.
Requisitos e limitações
O suporte a várias redes para pods tem os seguintes requisitos e limitações:
Requisitos
- GKE versão 1.28 ou posterior.
- Ative o Google Kubernetes Engine (GKE) Enterprise Edition.
- O suporte a várias redes para pods usa as mesmas especificações de VM que o multi-NIC para o Compute Engine.
- O suporte a várias redes para pods exige o GKE Dataplane V2.
- O suporte a várias redes para pods está disponível apenas para nós do Container-Optimized OS que executam a versão m101 ou posterior.
Limitações gerais
- O suporte a várias redes para pods não funciona para clusters ativados para rede de pilha dupla.
- A VPC compartilhada é compatível apenas com a versão 1.28 ou mais recente do GKE.
- O CIDR de vários pods não está disponível para clusters com várias redes ativadas.
- As redes de pod em um único cluster do GKE não podem ter intervalos CIDR sobrepostos.
- Ao ativar o suporte a várias redes para pods, não é possível adicionar ou remover interfaces de redes de nós ou redes de pods depois de criar um pool de nós. Para alterar essas configurações, recrie o pool de nós.
- Por padrão, o acesso à Internet não está disponível em interfaces adicionais de redes de pod dentro do pod. No entanto, é possível ativá-lo manualmente usando o Cloud NAT.
- Não é possível alterar o gateway padrão dentro de um pod com várias interfaces por meio da API. O gateway padrão precisa estar conectado à rede do pod padrão.
- A rede de pod padrão precisa sempre ser incluída em pods, mesmo que você crie redes ou interfaces de pods adicionais.
- Não é possível configurar o recurso de várias redes quando o Managed Hubble estiver configurado.
- Para usar a VPC compartilhada, verifique se o cluster do GKE está executando a versão 1.28.4 ou mais recente.
- Para implantações de VPC compartilhada, todas as interfaces de rede (NICs) anexadas aos nós precisam pertencer ao mesmo projeto que o projeto host.
Limitações do kit de desenvolvimento de plano de dados e dispositivos (DPDK)
- Uma NIC de VM transmitida para um pod como uma NIC do tipo
Device
não está disponível para outros pods no mesmo nó. - Os pods que usam o modo DPDK precisam ser executados no modo privilegiado para acessar dispositivos VFIO.
- No modo DPDK, um dispositivo é tratado como um recurso de nó e só é anexado ao primeiro contêiner (não init) no pod. Se você quiser dividir vários dispositivos DPDK entre contêineres no mesmo pod, execute esses contêineres em pods separados.
Limitações de escalonamento
O GKE fornece uma arquitetura de rede flexível que permite escalonar o cluster. É possível adicionar outras redes de nós e pods ao cluster. É possível escalonar o cluster da seguinte maneira:
- É possível adicionar até sete redes de nó extras a cada pool de nós do GKE. Esse é o mesmo limite de escala para VMs do Compute Engine.
- Cada pod precisa ter menos de sete redes adicionais anexadas.
- É possível configurar até 35 redes de pod nas oito redes de nós em um único pool de nós. É possível dividi-la em diferentes combinações, como:
- 7 redes de nós com 5 redes de pod cada
- 5 redes de nós com 7 redes de pod cada
- 1 rede de nó com 30 redes de pod. O limite para intervalos secundários por sub-rede é 30.
- É possível configurar até 50 redes de pod por cluster.
- É possível configurar até 32 pods de várias redes por nó.
- É possível ter até 3.000 nós com várias interfaces.
- É possível ter até 100.000 interfaces adicionais em todos os pods.
- É possível configurar até 1.000 nós com redes do tipo
Device
. - É possível configurar até quatro redes
Device
por nó.
Preços
Os recursos do Otimizador de funções de rede (NFO, na sigla em inglês), incluindo suporte a várias redes e de alto desempenho para pods, são compatíveis apenas com clusters que estão em projetos ativados com o GKE Enterprise. Para entender as cobranças aplicáveis à ativação do Google Kubernetes Engine (GKE) Enterprise, consulte Preços do GKE Enterprise.
Implantar pods de várias redes
Para implantar pods de várias redes, faça o seguinte:
- Prepare uma VPC adicional, uma sub-rede (rede de nó) e intervalos secundários (rede de pods).
- Crie um cluster do GKE em várias redes usando o comando da CLI do Google Cloud.
- Crie um novo pool de nós do GKE conectado à rede de nós e à rede de pods adicionais usando o comando da CLI do Google Cloud.
- Crie a rede do pod e faça referência aos intervalos secundários, de VPC e sub-rede corretos em objetos de várias redes usando a API Kubernetes.
- Na configuração da carga de trabalho, faça referência ao objeto Network preparado do Kubernetes usando a API Kubernetes.
Antes de começar
Antes de começar, verifique se você realizou as tarefas a seguir:
- Ativar a API Google Kubernetes Engine. Ativar a API Google Kubernetes Engine
- Se você quiser usar a Google Cloud CLI para essa tarefa,
instale e, em seguida,
inicialize a
CLI gcloud. Se você instalou a CLI gcloud anteriormente, instale a versão
mais recente executando
gcloud components update
.
Analise os requisitos e as limitações.
Preparar uma VPC adicional
O Google Cloud cria uma rede de pods padrão durante a criação do cluster associado
ao pool de nós do GKE usado durante a criação inicial do
cluster do GKE. A rede de pods padrão está disponível em todos os nós
e pods do cluster. Para facilitar os recursos de várias redes no pool de nós,
você precisa preparar VPCs atuais ou novas que ofereçam suporte a redes dos tipos Layer 3
e Device
.
Para preparar outra VPC, considere os seguintes requisitos:
Rede dos tipos
Layer 3
eNetdevice
:- Crie um intervalo secundário se você estiver usando redes do tipo
Layer 3
. - Verifique se o tamanho do CIDR para o intervalo secundário é grande o suficiente para atender ao número de nós no pool de nós e o número de pods por nó que você quer ter.
- Semelhante à rede de pods padrão, as outras redes de pods usam superprovisionamento de endereço IP. O intervalo de IP secundário precisa ter o dobro de endereços IP por nó que o número de pods por nó.
- Crie um intervalo secundário se você estiver usando redes do tipo
Requisitos de rede do tipo
Device
: crie uma sub-rede normal em uma VPC. Você não precisa de uma sub-rede secundária.
Para ativar os recursos de várias redes no pool de nós, prepare as VPCs com as quais você quer estabelecer conexões adicionais. É possível usar uma VPC atual ou Criar uma nova VPC especificamente para o pool de nós.
Crie uma rede VPC que ofereça suporte a um dispositivo do tipo Layer 3
Para criar uma rede VPC compatível com um dispositivo do tipo Layer 3
, faça
o seguinte:
- Verifique se o tamanho do CIDR para o intervalo secundário é grande o suficiente para atender ao número de nós no pool de nós e o número de pods por nó que você quer ter.
Semelhante à rede de pods padrão, as outras redes de pods usam superprovisionamento de endereço IP. O intervalo de endereço IP secundário precisa ter o dobro de endereços IP por nó que o número de pods por nó.
gcloud
gcloud compute networks subnets create SUBNET_NAME \
--project=PROJECT_ID \
--range=SUBNET_RANGE \
--network=NETWORK_NAME \
--region=REGION \
--secondary-range=SECONDARY_RANGE_NAME=<SECONDARY_RANGE_RANGE>
Substitua:
SUBNET_NAME
: o nome da sub-rede.PROJECT_ID
: o ID do projeto que contém a rede VPC em que a sub-rede é criada.SUBNET_RANGE
: o intervalo de endereços IPv4 principal da nova sub-rede, em notação CIDR.NETWORK_NAME
: o nome da rede VPC que contém a nova sub-rede.REGION
: a região do Google Cloud em que a nova sub-rede foi criada.SECONDARY_RANGE_NAME
: o nome do intervalo secundário.SECONDARY_IP_RANGE
é o intervalo de endereços IPv4 secundário na notação CIDR.
Console
No Console do Google Cloud, acesse a página Redes VPC.
Clique em Criar rede VPC.
No campo Nome, digite o nome da rede. Por exemplo,
l3-vpc
.No menu suspenso Unidade máxima de transmissão (MTU, na sigla em inglês), escolha o valor de MTU apropriado.
Na seção Modo de criação de sub-rede, escolha Personalizado.
Clique em ADICIONAR SUB-REDE.
Na seção Nova sub-rede, especifique os parâmetros de configuração a seguir para uma sub-rede:
Forneça um Nome. Por exemplo,
l3-subnet
.Selecione uma Região.
Digite um Intervalo de endereço IP. Esse é o intervalo IPv4 principal da sub-rede.
Se você selecionar um intervalo que não seja um endereço RFC 1918, confirme se não há incompatibilidade entre o intervalo e uma configuração existente. Para mais informações, consulte Intervalos de sub-rede IPv4.
Para definir um intervalo secundário da sub-rede, clique em Criar um intervalo secundário de endereço IP.
Se você selecionar um intervalo que não seja um endereço RFC 1918, confirme se não há incompatibilidade entre o intervalo e uma configuração existente. Para mais informações, consulte Intervalos de sub-rede IPv4.
Acesso privado do Google: é possível ativar o Acesso privado do Google para a sub-rede ao criá-la ou depois, editando-a.
Registros de fluxo: é possível ativar registros de fluxo de VPC para a sub-rede ao criá-la ou depois, editando-a.
Clique em Concluído.
Na seção Regras de firewall, em Regras de firewall IPv4, selecione zero ou mais regras de firewall predefinidas.
As regras abordam casos de uso comuns para o processo de conexão a instâncias. É possível criar suas próprias regras de firewall, depois de criar a rede. Cada nome de regra predefinido começa com o nome da rede VPC que você está criando.
Em Regras de firewall IPv4, para editar a regra de firewall de entrada predefinida chamada
allow-custom
, clique em EDITAR.É possível editar sub-redes, adicionar outros intervalos IPv4 e especificar protocolos e portas.
A regra de firewall
allow-custom
não será atualizada automaticamente se você adicionar outras sub-redes posteriormente. Se você precisar de regras de firewall para as novas sub-redes, atualize a configuração do firewall para adicioná-las.Na seção Modo de roteamento dinâmico, para a rede VPC. Para saber mais informações, consulte modo de roteamento dinâmico. É possível alterar o modo de roteamento dinâmico mais tarde.
Clique em Criar.
Crie uma rede VPC compatível com dispositivos do tipo Netdevice
ou DPDK
gcloud
gcloud compute networks subnets create SUBNET_NAME \
--project=PROJECT_ID \
--range=SUBNET_RANGE \
--network=NETWORK_NAME \
--region=REGION \
--secondary-range=SECONDARY_RANGE_NAME=<SECONDARY_RANGE_RANGE>
Substitua:
SUBNET_NAME
: o nome da sub-rede.PROJECT_ID
: o ID do projeto que contém a rede VPC em que a sub-rede é criada.SUBNET_RANGE
: o intervalo de endereços IPv4 principal da nova sub-rede, em notação CIDR.NETWORK_NAME
: o nome da rede VPC que contém a nova sub-rede.REGION
: a região do Google Cloud em que a nova sub-rede foi criada.SECONDARY_RANGE_NAME
: o nome do intervalo secundário.SECONDARY_IP_RANGE
é o intervalo de endereços IPv4 secundário na notação CIDR.
Console
No Console do Google Cloud, acesse a página Redes VPC.
Clique em Criar rede VPC.
No campo Nome, digite o nome da rede. Por exemplo,
netdevice-vpc
oudpdk-vpc
.No menu suspenso Unidade máxima de transmissão (MTU, na sigla em inglês), escolha o valor de MTU apropriado.
Na seção Modo de criação de sub-rede, escolha Personalizado.
Na seção Nova sub-rede, especifique os parâmetros de configuração a seguir para uma sub-rede:
Forneça um Nome. Por exemplo,
netdevice-subnet
oudpdk-vpc
.Selecione uma Região.
Digite um Intervalo de endereço IP. Esse é o intervalo IPv4 principal da sub-rede.
Se você selecionar um intervalo que não seja um endereço RFC 1918, confirme se não há incompatibilidade entre o intervalo e uma configuração existente. Para mais informações, consulte Intervalos de sub-rede IPv4.
Acesso privado do Google: escolha se você quer ativar o Acesso privado do Google para a sub-rede ao criá-la ou mais tarde, editando-a.
Registros de fluxo: é possível ativar registros de fluxo de VPC para a sub-rede ao criá-la ou depois, editando-a.
Clique em Concluído.
Na seção Regras de firewall, em Regras de firewall IPv4, selecione zero ou mais regras de firewall predefinidas.
As regras abordam casos de uso comuns para o processo de conexão a instâncias. É possível criar suas próprias regras de firewall, depois de criar a rede. Cada nome de regra predefinido começa com o nome da rede VPC que você está criando.
Em Regras de firewall IPv4, para editar a regra de firewall de entrada predefinida chamada
allow-custom
, clique em EDITAR.É possível editar sub-redes, adicionar outros intervalos IPv4 e especificar protocolos e portas.
A regra de firewall
allow-custom
não será atualizada automaticamente se você adicionar outras sub-redes posteriormente. Se você precisar de regras de firewall para as novas sub-redes, atualize a configuração do firewall para adicioná-las.Na seção Modo de roteamento dinâmico, para a rede VPC. Para saber mais informações, consulte modo de roteamento dinâmico. É possível alterar o modo de roteamento dinâmico mais tarde.
Clique em Criar.
Criar um cluster do GKE com recursos de várias redes
gcloud
Para criar um cluster do GKE com recursos de várias redes:
gcloud container clusters create CLUSTER_NAME \
--cluster-version=CLUSTER_VERSION \
--enable-dataplane-v2 \
--enable-ip-alias \
--enable-multi-networking
Substitua:
CLUSTER_NAME
: o nome do cluster.CLUSTER_VERSION
: a versão do cluster.
Esse comando inclui as seguintes sinalizações:
--enable-multi-networking:
ativa as definições de recursos personalizados (CRDs, na sigla em inglês) de várias redes no servidor de API deste cluster e implanta um gerenciador de controlador de rede que contém a reconciliação e o gerenciamento do ciclo de vida para objetos de várias redes.--enable-dataplane-v2:
ativa o GKE Dataplane V2. Essa sinalização é necessária para ativar várias redes.
Console
Acesse a página Google Kubernetes Engine no console do Google Cloud.
Clique em add_box Criar.
Configure o cluster padrão. Para mais informações, consulte Criar um cluster de zona ou Criar um cluster regional. Ao criar o cluster, selecione a sub-rede de nó e de rede apropriada.
No painel de navegação, em Cluster, clique em Rede.
Marque a caixa de seleção Ativar o Dataplane V2.
Selecione Ativar várias redes.
Clique em Criar.
A ativação de várias redes para um cluster adiciona as CustomResourceDefinitions (CRDs) necessárias ao servidor de API para esse cluster. Ele também implanta um controlador de rede, que é responsável por reconciliar e gerenciar objetos de várias redes. Não é possível modificar a configuração do cluster depois que ele é criado.
Criar um pool de nós do GKE conectado a outras VPCs
Crie um pool de nós que inclua nós conectados à rede de nós (VPC e sub-rede) e à rede de pods (intervalo secundário) criados em Criar rede de pods.
Para criar o novo pool de nós e associá-lo às redes adicionais no cluster do GKE:
gcloud
gcloud container node-pools create POOL_NAME \
--cluster=CLUSTER_NAME \
--additional-node-network network=NETWORK_NAME,subnetwork=SUBNET_NAME \
--additional-pod-network subnetwork=subnet-dp,pod-ipv4-range=POD_IP_RANGE,max-pods-per-node=NUMBER_OF_PODS \
--additional-node-network network=highperformance,subnetwork=subnet-highperf
Substitua:
POOL_NAME
pelo nome do novo pool de nós.CLUSTER_NAME
pelo nome do cluster atual ao qual você está adicionando o pool de nós.NETWORK_NAME
pelo nome da rede para anexar os nós do pool de nós.SUBNET_NAME
pelo nome da sub-rede dentro da rede a ser usada para os nós.POD_IP_RANGE
é o intervalo de endereços IP do pod na sub-rede.NUMBER_OF_PODS
número máximo de pods por nó.
Esse comando contém as seguintes sinalizações:
--additional-node-network
: define os detalhes da interface de rede, da rede e da sub-rede adicionais. Isso é usado para especificar as redes de nós para conexão com os nós do pool de nós. Especifique esse parâmetro quando quiser se conectar a outra VPC. Se você não especificar esse parâmetro, a VPC padrão associada ao cluster será usada. Para redes do tipoLayer 3
, especifique a sinalizaçãoadditional-pod-network
que define a rede do pod, que é exposta dentro do cluster do GKE como o objetoNetwork
. Ao usar a sinalização--additional-node-network
, você precisa fornecer uma rede e uma sub-rede como parâmetros obrigatórios. Certifique-se de separar os valores de rede e sub-rede com uma vírgula e evite usar espaços.--additional-pod-network
: especifica os detalhes do intervalo secundário a ser usado para a rede de pods. Esse parâmetro não é obrigatório se você usa uma rede do tipoDevice
. Esse argumento especifica os seguintes valores de chave:subnetwork
,pod-ipv4-range
emax-pods-per-node
. Ao usar o--additional-pod-network
, você precisa fornecer os valorespod-ipv4-range
emax-pods-per-node
, separados por vírgulas e sem espaços.subnetwork
: vincula a rede do nó à rede do pod. A sub-rede é opcional. Se você não especificar isso, a rede de pods extra será associada à sub-rede padrão fornecida durante a criação do cluster.--max-pods-per-node
: omax-pods-per-node
precisa ser especificado e precisa ter uma potência de 2. O valor mínimo é 4.max-pods-per-node
não pode ser maior que o valormax-pods-per-node
no pool de nós.
Console
Acesse a página Google Kubernetes Engine no console do Google Cloud.
No painel de navegação, clique em Clusters.
Na seção Clusters do Kubernetes, clique no cluster que você criou.
Na parte de cima da página, para criar o pool de nós, clique em add_box Adicionar pool de nós.
Na seção Detalhes do pool de nós, preencha o seguinte:
- Insira um Nome para o pool de nós.
- Digite o Número de nós a serem criados no pool de nós.
No painel de navegação, em Pools de nós, clique em Nós.
Na lista suspensa Tipo de imagem, selecione a imagem de nó Container-Optimized OS com containerd (cos_containerd).
Ao criar uma VM, você seleciona um tipo de máquina de uma família de máquina que determina os recursos disponíveis para ela. Por exemplo, um tipo de máquina como
e2-standard-4
contém quatro vCPUs, portanto, aceita até quatro VPCs no total. Há várias famílias de máquina disponíveis, cada uma organizada em série e em tipos predefinidos ou personalizados em cada série. A cobrança varia de acordo com cada tipo de máquina. Para mais informações, consulte a Tabela de preços do tipo de máquina.No painel de navegação, selecione Rede.
Na seção Rede de nós, especifique o número máximo de pods por nó. A seção Redes de nós mostra a rede VPC utilizada para criar o cluster. É necessário designar redes de nós extras correlacionadas com redes VPC e tipos de dispositivos estabelecidos anteriormente.
Criar associação de pool de nós:
- Para dispositivos do tipo
Layer 3
:- Na seção Redes de nós, clique em ADICIONAR UMA REDE DE NÓ.
- Na lista suspensa de rede, selecione a VPC compatível com o dispositivo do tipo Camada 3.
- Selecione a sub-rede criada para a VPC
Layer 3
. - Na seção Intervalos de endereços IP do pod do alias, clique em Adicionar intervalo de endereços IP do pod.
- Selecione a Sub-rede secundária e indique o Número máximo de pods por nó.
- Selecione Concluído.
- Para o dispositivo do tipo
Netdevice
eDPDK
:- Na seção Redes de nós, clique em ADICIONAR UMA REDE DE NÓ.
- Na lista suspensa de rede, selecione a VPC compatível com dispositivos dos tipos
Netdevice
ouDPDK
. - Selecione a sub-rede criada para a VPC
Netdevice
ouDPDK
. - Selecione Concluído.
- Para dispositivos do tipo
Clique em Criar.
Observações:
- Se várias redes de pods adicionais forem especificadas na mesma rede de nós, elas precisarão estar na mesma sub-rede.
- Não é possível referenciar o mesmo intervalo secundário de uma sub-rede várias vezes.
Exemplo
O exemplo a seguir cria um pool de nós chamado pool-multi-net que anexa duas
outras redes aos nós: datapalane (rede do tipo Layer 3
) e
alto desempenho (tipo de dispositivo de rede). Este exemplo pressupõe que você já
criou um cluster do GKE chamado cluster-1
:
gcloud container node-pools create pool-multi-net \
--project my-project \
--cluster cluster-1 \
--zone us-central1-c \
--additional-node-network network=dataplane,subnetwork=subnet-dp \
--additional-pod-network subnetwork=subnet-dp,pod-ipv4-range=sec-range-blue,max-pods-per-node=8 \
--additional-node-network network=highperformance,subnetwork=subnet-highperf
Para especificar outras interfaces de rede de nós e pods, defina os parâmetros --additional-node-network
e --additional-pod-network
várias vezes, conforme mostrado no exemplo a seguir:
--additional-node-network network=dataplane,subnetwork=subnet-dp \
--additional-pod-network subnetwork=subnet-dp,pod-ipv4-range=sec-range-blue,max-pods-per-node=8 \
--additional-pod-network subnetwork=subnet-dp,pod-ipv4-range=sec-range-green,max-pods-per-node=8 \
--additional-node-network network=managementdataplane,subnetwork=subnet-mp \
--additional-pod-network subnetwork=subnet-mp,pod-ipv4-range=sec-range-red,max-pods-per-node=4
Para especificar outras redes de pods diretamente na interface da VPC principal do pool de nós, conforme mostrado no exemplo a seguir:
--additional-pod-network subnetwork=subnet-def,pod-ipv4-range=sec-range-multinet,max-pods-per-node=8
Criar rede do pod
Defina as redes de pods que os pods acessarão definindo objetos do Kubernetes e vinculando-os aos recursos correspondentes do Compute Engine, como VPCs, sub-redes e intervalos secundários.
Para criar uma rede de pods, defina os objetos de CRD de rede no cluster.
Configurar a rede VPC Layer 3
YAML
Para a VPC Layer 3
, crie objetos Network
e GKENetworkParamSet
:
Salve o seguinte manifesto de amostra como
blue-network.yaml
:apiVersion: networking.gke.io/v1 kind: Network metadata: name: blue-network spec: type: "L3" parametersRef: group: networking.gke.io kind: GKENetworkParamSet name: "l3-vpc"
O manifesto define um recurso
Network
chamadoblue-network
do tipoLayer 3
. O objetoNetwork
faz referência ao objetoGKENetworkParamSet
chamadol3-vpc
, que associa uma rede aos recursos do Compute Engine.Aplique o manifesto ao cluster:
kubectl apply -f blue-network.yaml
Salve o seguinte manifesto como
dataplane.yaml
:apiVersion: networking.gke.io/v1 kind: GKENetworkParamSet metadata: name: "l3-vpc" spec: vpc: "l3-vpc" vpcSubnet: "subnet-dp" podIPv4Ranges: rangeNames: - "sec-range-blue"
Esse manifesto define o objeto
GKENetworkParamSet
chamadodataplane
, define o nome da VPC comodataplane
, nome da sub-rede comosubnet-dp
e um intervalo de endereços IPv4 secundário para pods chamadossec-range-blue
.Aplique o manifesto ao cluster:
kubectl apply -f dataplane.yaml
Console
Acesse a página Google Kubernetes Engine no console do Google Cloud.
No painel de navegação, clique em Gerenciador de funções da rede.
Clique em Ativar GKE Enterprise.
Na parte superior da página, clique em add_box Criar para criar a rede do pod.
Na seção Antes de começar, verifique os detalhes.
Clique em PRÓXIMO: LOCAL DA REDE DE POD.
Na seção Local da rede do pod, no menu suspenso Cluster, selecione o cluster do GKE que tenha várias redes e o GKE Dataplane V2 ativado.
Clique em PRÓXIMO: REFERÊNCIA DE REDE VPC.
Na seção Referência da rede VPC, no menu suspenso Referência da rede VPC, selecione a rede VPC usada para pods multinic
Layer 3
.Clique em PRÓXIMO: TIPO DE REDE DE POD.
Na seção Tipo de rede do pod, selecione L3 e insira o nome da rede do pod.
Clique em PRÓXIMO: FAIXA SECUNDÁRIA DA REDE DE POD.
Na seção Intervalo secundário da rede do pod, insira o Intervalo secundário.
Clique em PRÓXIMO: ROTAS DA REDE DE POD.
Na seção Rotas de rede do pod, para definir Rotas personalizadas, selecione ADICIONAR ROTA.
Clique em CRIAR REDE DE POD.
Configurar rede DPDK
YAML
Para a VPC do DPDK, crie objetos Network
e GKENetworkParamSet
.
Salve o seguinte manifesto de amostra como
dpdk-network.yaml
:apiVersion: networking.gke.io/v1 kind: Network metadata: name: dpdk-network spec: type: "Device" parametersRef: group: networking.gke.io kind: GKENetworkParamSet name: "dpdk"
Esse manifesto define um recurso
Network
chamadodpdk-network
com um tipo deDevice
. O recursoNetwork
se refere a um objetoGKENetworkParamSet
chamadodpdk
para a configuração.Aplique o manifesto ao cluster:
kubectl apply -f dpdk-network.yaml
Para o objeto
GKENetworkParamSet
, salve o seguinte manifesto comodpdk.yaml
:apiVersion: networking.gke.io/v1 kind: GKENetworkParamSet metadata: name: "dpdk" spec: vpc: "dpdk" vpcSubnet: "subnet-dpdk" deviceMode: "DPDK-VFIO"
Esse manifesto define o objeto
GKENetworkParamSet
chamadodpdk
, define o nome da VPC comodpdk
, o nome da sub-rede comosubnet-dpdk
e o nome de deviceMode comoDPDK-VFIO
.Aplique o manifesto ao cluster:
kubectl apply -f dpdk-network.yaml
Console
Acesse a página Google Kubernetes Engine no console do Google Cloud.
No painel de navegação, clique em Gerenciador de funções da rede.
Na parte superior da página, clique em add_box Criar para criar a rede do pod.
Na seção Antes de começar, verifique os detalhes.
Clique em PRÓXIMO: LOCAL DA REDE DE POD.
Na seção Local da rede do pod, no menu suspenso Cluster, selecione o cluster do GKE que tenha várias redes e o GKE Dataplane V2 ativado.
Clique em PRÓXIMO: REFERÊNCIA DE REDE VPC.
Na seção Referência da rede VPC, no menu suspenso Referência da rede VPC, selecione a rede VPC usada para pods multinic dpdk.
Clique em PRÓXIMO: TIPO DE REDE DE POD.
Na seção Tipo de rede do pod, selecione DPDK-VFIO (dispositivo) e insira o Nome da rede do pod.
Clique em PRÓXIMO: FAIXA SECUNDÁRIA DA REDE DE POD. A seção do intervalo secundário da rede do pod não estará disponível
Clique em PRÓXIMO: ROTAS DA REDE DE POD. Na seção Rotas de rede do pod, selecione ADICIONAR ROTA para definir rotas personalizadas
Clique em CRIAR REDE DE POD.
Configurar rede netdevice
Para a VPC netdevice
, crie objetos Network
e GKENetworkParamSet
.
YAML
Salve o seguinte manifesto de amostra como
netdevice-network.yaml
:apiVersion: networking.gke.io/v1 kind: Network metadata: name: netdevice-network spec: type: "Device" parametersRef: group: networking.gke.io kind: GKENetworkParamSet name: "netdevice"
Esse manifesto define um recurso
Network
chamadonetdevice-network
com um tipo deDevice
. Ele faz referência ao objetoGKENetworkParamSet
chamadonetdevice
.Aplique o manifesto ao cluster:
kubectl apply -f netdevice-network.yaml
Salve o seguinte manifesto como
netdevice.yaml
:apiVersion: networking.gke.io/v1 kind: GKENetworkParamSet metadata: name: netdevice spec: vpc: netdevice vpcSubnet: subnet-netdevice deviceMode: NetDevice
Esse manifesto define um recurso
GKENetworkParamSet
chamadonetdevice
, define o nome da VPC comonetdevice
, o nome da sub-rede comosubnet-netdevice
e especifica o modo do dispositivo comoNetDevice
.Aplique o manifesto ao cluster:
kubectl apply -f netdevice.yaml
Console
Acesse a página Google Kubernetes Engine no console do Google Cloud.
No painel de navegação, clique em Gerenciador de funções da rede.
Na parte superior da página, clique em add_box Criar para criar a rede do pod.
Na seção Antes de começar, verifique os detalhes.
Clique em PRÓXIMO: LOCAL DA REDE DE POD.
Na seção Local da rede do pod, no menu suspenso Cluster, selecione o cluster do GKE que tenha várias redes e o GKE Dataplane V2 ativado.
Clique em PRÓXIMO: REFERÊNCIA DE REDE VPC.
Na seção Referência da rede VPC, no menu suspenso Referência da rede VPC, selecione a rede VPC usada para os pods multinic do netdevice.
Clique em PRÓXIMO: TIPO DE REDE DE POD.
Na seção Tipo de rede do pod, selecione NetDevice (Device) e insira o Nome da rede do pod.
Clique em PRÓXIMO: FAIXA SECUNDÁRIA DA REDE DE POD. A seção do intervalo secundário da rede do pod não estará disponível
Clique em PRÓXIMO: ROTAS DA REDE DE POD. Na seção Rotas de rede do pod, para definir rotas personalizadas, selecione ADICIONAR ROTA.
Clique em CRIAR REDE DE POD.
Como configurar rotas de rede
A configuração da rota de rede permite definir rotas personalizadas para uma rede específica, que são configuradas nos pods para direcionar o tráfego para a interface correspondente dentro do pod.
YAML
Salve o seguinte manifesto como
red-network.yaml
:apiVersion: networking.gke.io/v1 kind: Network metadata: name: red-network spec: type: "L3" parametersRef: group: networking.gke.io kind: GKENetworkParamSet name: "management" routes: - to: "10.0.2.0/28"
Esse manifesto define um recurso de rede chamado
red-network
com um tipo deLayer 3
e uma rota personalizada "10.0.2.0/28" por meio dessa interface de rede.Aplique o manifesto ao cluster:
kubectl apply -f red-network.yaml
Console
Acesse a página Google Kubernetes Engine no console do Google Cloud.
Clique em add_box Criar.
No painel de navegação, clique em Gerenciador de funções da rede.
Na seção Clusters do Kubernetes, clique no cluster que você criou.
Na parte superior da página, clique em add_box Criar para criar a rede do pod.
Na seção Rotas de rede do pod, defina Rotas personalizadas.
Clique em CRIAR REDE DE POD.
Consulte a Network
preparada
Na configuração da carga de trabalho, faça referência ao objeto Network
do Kubernetes preparado usando a API Kubernetes.
Conectar o pod a redes específicas
Para conectar pods às redes especificadas, inclua os nomes dos objetos Network
como anotações dentro da configuração do pod. Certifique-se de
incluir o default
Network
e as redes adicionais selecionadas nas
anotações para estabelecer as conexões.
Salve o seguinte manifesto de amostra como
sample-l3-pod.yaml
:apiVersion: v1 kind: Pod metadata: name: sample-l3-pod annotations: networking.gke.io/default-interface: 'eth0' networking.gke.io/interfaces: | [ {"interfaceName":"eth0","network":"default"}, {"interfaceName":"eth1","network":"l3-network"} ] spec: containers: - name: sample-l3-pod image: busybox command: ["sleep", "10m"] ports: - containerPort: 80 restartPolicy: Always
Esse manifesto cria um pod chamado
sample-l3-pod
com duas interfaces de rede,eth0
eeth1
, associadas às redesdefault
eblue-network
, respectivamente.Aplique o manifesto ao cluster:
kubectl apply -f sample-l3-pod.yaml
Conectar o pod com várias redes
Salve o seguinte manifesto de amostra como
sample-l3-netdevice-pod.yaml
:apiVersion: v1 kind: Pod metadata: name: sample-l3-netdevice-pod annotations: networking.gke.io/default-interface: 'eth0' networking.gke.io/interfaces: | [ {"interfaceName":"eth0","network":"default"}, {"interfaceName":"eth1","network":"l3-network"}, {"interfaceName":"eth2","network":"netdevice-network"} ] spec: containers: - name: sample-l3-netdevice-pod image: busybox command: ["sleep", "10m"] ports: - containerPort: 80 restartPolicy: Always
Esse manifesto cria um pod chamado
sample-l3-netdevice-pod
com três interfaces de rede,eth0
eeth1
eeth2
associadas às redesdefault
,l3-network
enetdevice
respectivamente.Aplique o manifesto ao cluster:
kubectl apply -f sample-l3-netdevice-pod.yaml
É possível usar a mesma anotação em qualquer ReplicaSet (Implantação ou DaemonSet) na seção de anotação do modelo.
Quando você cria um pod com uma especificação de várias redes, os componentes do plano de dados geram automaticamente a configuração de interfaces do pod e as salvam nas respostas automáticas NetworkInterface
. Crie uma resposta automática NetworkInterface
para cada Network
não padrão especificado na especificação do pod.
Por exemplo, o manifesto a seguir mostra detalhes de um manifesto NetworkInterface
:
apiVersion: v1
items:
- apiVersion: networking.gke.io/v1
kind: NetworkInterface
metadata:
labels:
podName: samplepod
name: "samplepod-c0b60cbe"
namespace: default
spec:
networkName: "blue-network"
status:
gateway4: 172.16.1.1
ipAddresses:
- 172.16.1.2/32
macAddress: 82:89:96:0b:92:54
podName: samplepod
Esse manifesto inclui o nome da rede, o endereço do gateway, os endereços IP atribuídos, o endereço MAC e o nome do pod.
Exemplo de configuração de um pod com várias interfaces:
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
inet 127.0.0.1/8 scope host lo
valid_lft forever preferred_lft forever
2: eth0@if9: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1460 qdisc noqueue state UP group default
link/ether 2a:92:4a:e5:da:35 brd ff:ff:ff:ff:ff:ff link-netnsid 0
inet 10.60.45.4/24 brd 10.60.45.255 scope global eth0
valid_lft forever preferred_lft forever
10: eth1@if11: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1460 qdisc noqueue state UP group default qlen 1000
link/ether ba:f0:4d:eb:e8:02 brd ff:ff:ff:ff:ff:ff link-netnsid 0
inet 172.16.1.2/32 scope global eth1
valid_lft forever preferred_lft forever
Verificação
- Crie clusters com
--enable-multi-networking
somente se--enable-dataplane-v2
estiver ativado. - Verifique se todos os pools de nós no cluster estão executando imagens do Container-Optimized OS no momento da criação do cluster e do pool de nós.
- Verifique se os pools de nós serão criados com
--additional-node-network
ou--additional-pod-network
somente se a rede estiver ativada no cluster. - Verifique se a mesma sub-rede não é especificada duas vezes como argumento
--additional-node-network
para um pool de nós. - Verifique se o mesmo intervalo secundário não está especificado como o argumento
--additional-pod-network
para um pool de nós. - Siga os limites de escala especificados para objetos de rede, considerando o número máximo de nós, pods e endereços IP permitidos.
- Verifique se há apenas um objeto
GKENetworkParamSet
que se refira a uma sub-rede e um intervalo secundários específicos. - Verifique se cada objeto de rede se refere a um objeto
GKENetworkParamSet
diferente. - Verifique se o objeto de rede, se for criado com uma sub-rede específica com a rede
Device
, não está sendo usado no mesmo nó com outra rede com um intervalo secundário. Só é possível validar isso no tempo de execução. - Verifique se os vários intervalos secundários atribuídos aos pools de nós não têm endereços IP sobrepostos.
Resolver problemas de parâmetros de várias redes no GKE
Quando você cria um cluster e um pool de nós, o Google Cloud implementa determinadas verificações para garantir que apenas parâmetros válidos de várias redes sejam permitidos. Isso garante que a rede esteja configurada corretamente para o cluster.
Se você não conseguir criar cargas de trabalho de várias redes, verifique o status e os eventos do pod para mais informações:
kubectl describe pods samplepod
O resultado será assim:
Name: samplepod
Namespace: default
Status: Running
IP: 192.168.6.130
IPs:
IP: 192.168.6.130
...
Events:
Type Reason Age From Message
---- ------ ---- ---- -------
Normal Scheduled 26m default-scheduler Successfully assigned default/samplepod to node-n1-04
Warning FailedCreatePodSandBox 26m kubelet Failed to create pod sandbox: rpc error: code = Unknown desc = failed to setup network for sandbox "e16c58a443ab70d671159509e36894b57493300ea21b6c24c14bdc412b0fdbe6": Unable to create endpoint: [PUT /endpoint/{id}][400] putEndpointIdInvalid failed getting interface and network CR for pod "default/samplepod": failed creating interface CR default/samplepod-c0b60cbe: admission webhook "vnetworkinterface.networking.gke.io" denied the request: NetworkInterface.networking.gke.io "samplepod-c0b60cbe" is invalid: Spec.NetworkName: Internal error: failed to get the referenced network "sample-network": Network.networking.gke.io "sample-network" not found
...
Veja a seguir motivos gerais para a falha na criação de pods:
- Falha ao programar pod porque os requisitos de recursos de várias redes não foram atendidos
- Falha ao identificar redes especificadas
- Falha ao configurar e criar o objeto de interface de rede para o pod
Para inspecionar se o Google Cloud criou os objetos NetworkInterface
no servidor de API, execute o seguinte comando:
kubectl get networkinterfaces.networking.gke.io -l podName=samplepod
Resolver problemas na criação de redes do Kubernetes
Depois de criar uma rede, os nós que precisam ter acesso à rede configurada são anotados com uma anotação de status de rede.
Para observar as anotações, execute o seguinte comando:
kubectl describe node NODE_NAME
Substitua NODE_NAME
pelo nome do nó.
O resultado será assim:
networking.gke.io/network-status: [{"name":"default"},{"name":"dp-network"}]
A saída lista cada rede disponível no nó. Se o status da rede esperado não for visto no nó, faça o seguinte:
Verificar se o nó pode acessar a rede
Se a rede não estiver aparecendo na anotação de status da rede do nó:
- Verifique se o nó faz parte de um pool configurado para várias redes.
- Verifique as interfaces do nó para ver se ele tem uma interface para a rede que você está configurando.
- Se um nó não tiver status de rede e tiver apenas uma interface de rede, ainda será necessário criar um pool de nós com várias redes ativadas.
- Se o nó contiver a interface da rede que você está configurando, mas
não for visto na anotação de status da rede, verifique os recursos
Network
eGKENetworkParamSet
(GNP).
Verifique os recursos Network
e GKENetworkParamSet
O status dos recursos Network
e GKENetworkParamSet
(GNP) inclui um campo de condições para relatar erros de configuração. Recomendamos verificar o GNP primeiro, porque ele não depende de outro recurso para ser válido.
Para inspecionar o campo de condições, execute o seguinte comando:
kubectl get gkenetworkparamsets GNP_NAME -o yaml
Substitua GNP_NAME
pelo nome do recurso GKENetworkParamSet
.
Quando a condição Ready
for igual a "true", a configuração será válida e a
saída será semelhante a esta:
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
...
spec:
podIPv4Ranges:
rangeNames:
- sec-range-blue
vpc: dataplane
vpcSubnet: subnet-dp
status:
conditions:
- lastTransitionTime: "2023-06-26T17:38:04Z"
message: ""
reason: GNPReady
status: "True"
type: Ready
networkName: dp-network
podCIDRs:
cidrBlocks:
- 172.16.1.0/24
Quando a condição Ready
é igual a falso, a saída exibe o motivo e é semelhante a esta:
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
...
spec:
podIPv4Ranges:
rangeNames:
- sec-range-blue
vpc: dataplane
vpcSubnet: subnet-nonexist
status:
conditions:
- lastTransitionTime: "2023-06-26T17:37:57Z"
message: 'subnet: subnet-nonexist not found in VPC: dataplane'
reason: SubnetNotFound
status: "False"
type: Ready
networkName: ""
Se você encontrar uma mensagem semelhante, verifique se seu NPS foi configurado corretamente. Se já estiver, verifique se a configuração de rede do Google Cloud está correta. Depois de atualizar a configuração de rede do Google Cloud, talvez seja necessário recriar o recurso GNP para acionar manualmente uma ressincronização. Isso evita a pesquisa infinita da API do Google Cloud.
Quando o PIB estiver pronto, verifique o recurso Network
.
kubectl get networks NETWORK_NAME -o yaml
Substitua NETWORK_NAME
pelo nome do recurso Network
.
A saída de uma configuração válida é semelhante a esta:
apiVersion: networking.gke.io/v1
kind: Network
...
spec:
parametersRef:
group: networking.gke.io
kind: GKENetworkParamSet
name: dp-gnp
type: L3
status:
conditions:
- lastTransitionTime: "2023-06-07T19:31:42Z"
message: ""
reason: GNPParamsReady
status: "True"
type: ParamsReady
- lastTransitionTime: "2023-06-07T19:31:51Z"
message: ""
reason: NetworkReady
status: "True"
type: Ready
reason: NetworkReady
indica que o recurso de rede está configurado corretamente.reason: NetworkReady
não implica que o recurso de rede está necessariamente disponível em um nó específico ou está sendo usado ativamente.- Se houver um erro de configuração ou erro, o campo
reason
na condição especificará o motivo exato do problema. Nesses casos, ajuste a configuração de acordo. - O GKE preencherá o campo ParamsReady se o campo parametersRef
for definido como um recurso
GKENetworkParamSet
existente no cluster. Se você especificou umGKENetworkParamSet
typeRef e a condição não estiver aparecendo, verifique se o nome, o tipo e o grupo correspondem ao recurso GNP existente no cluster.