Configurar o balanceamento de carga de camada 4 multicluster nos clusters membros do Azure Kubernetes Fleet Manager (pré-visualização)

Para aplicativos implantados em vários clusters, os administradores geralmente desejam rotear o tráfego de entrada para eles em clusters.

Você pode seguir este documento para configurar o balanceamento de carga de camada 4 para esses aplicativos multicluster.

Importante

As funcionalidades em versão prévia do Azure Kubernetes Fleet Manager estão disponíveis num modelo de autoatendimento e adesão voluntária. As visualizações prévias são fornecidas "como estão" e "conforme disponíveis" e são excluídas dos contratos de nível de serviço e da garantia limitada. As visualizações do Azure Kubernetes Fleet Manager são parcialmente cobertas pelo suporte ao cliente em regime de esforços possíveis. Como tal, estas funcionalidades não se destinam a utilização em produção.

Pré-requisitos

Se não tiver uma conta do Azure, crie uma conta gratuita antes de começar.

Leia a visão geral conceitual desta funcionalidade, que fornece uma explicação dos objetos ServiceExport e MultiClusterService mencionados neste documento.
Você deve ter um recurso de frota com um cluster central e clusters de membros. Se não tiver esse recurso, siga Início rápido: criar um recurso de frota e juntar-se a clusters de membros.
Os clusters de destino do Serviço Kubernetes do Azure (AKS) nos quais as cargas de trabalho são implantadas precisam estar presentes na mesma rede virtual ou em redes virtuais emparelhadas.
- Estes clusters de destino têm de ser adicionados como clusters membros ao recurso da Frota.
- Esses clusters de destino devem estar usando a rede CNI (Container Networking Interface) do Azure.
Você deve obter acesso à API do Kubernetes do cluster de hub seguindo as etapas em Access Fleet hub cluster Kubernetes API.

Defina as seguintes variáveis de ambiente e obtenha os kubeconfigs para a frota e todos os clusters membros:

export GROUP=<resource-group>
export FLEET=<fleet-name>
export MEMBER_CLUSTER_1=aks-member-1
export MEMBER_CLUSTER_2=aks-member-2

az fleet get-credentials --resource-group ${GROUP} --name ${FLEET} --file fleet

az aks get-credentials --resource-group ${GROUP} --name ${MEMBER_CLUSTER_1} --file aks-member-1

az aks get-credentials --resource-group ${GROUP} --name ${MEMBER_CLUSTER_2} --file aks-member-2

Use o ambiente Bash no Azure Cloud Shell. Para obter mais informações, consulte Introdução ao Azure Cloud Shell.
Se preferir executar comandos de referência da CLI localmente, instale a CLI do Azure. Se estiver a utilizar o Windows ou macOS, considere executar a CLI do Azure num contentor Docker. Para obter mais informações, consulte Como executar a CLI do Azure em um contêiner do Docker.
- Se estiver a utilizar uma instalação local, inicie sessão no CLI do Azure ao utilizar o comando az login. Para concluir o processo de autenticação, siga os passos apresentados no seu terminal. Para outras opções de entrada, consulte Autenticar no Azure usando a CLI do Azure.
- Quando solicitado, instale a extensão da CLI do Azure na primeira utilização. Para obter mais informações sobre extensões, consulte Usar e gerenciar extensões com a CLI do Azure.
- Execute o comando az version para localizar a versão e as bibliotecas dependentes instaladas. Para atualizar para a versão mais recente, execute o comando az upgrade.

Implantar uma carga de trabalho entre clusters membros do recurso Fleet

Nota

As etapas neste guia de instruções referem-se a um aplicativo de exemplo apenas para fins de demonstração. Você pode substituir essa carga de trabalho por qualquer um dos seus próprios objetos de Implantação e Serviço existentes.
Essas etapas desdobram a carga de trabalho de exemplo do cluster Fleet para os clusters membros usando a configuração de propagação do Kubernetes. Como alternativa, você pode optar por implantar essas configurações do Kubernetes em cada cluster membro separadamente, uma de cada vez.

Crie um namespace no cluster de frota:

KUBECONFIG=fleet kubectl create namespace kuard-demo

A saída é semelhante ao exemplo a seguir:

namespace/kuard-demo created

Aplique os objetos Deployment, Service, ServiceExport:
```
KUBECONFIG=fleet kubectl apply -f https://raw.githubusercontent.com/Azure/AKS/master/examples/fleet/kuard/kuard-export-service.yaml
```
A especificação ServiceExport no arquivo acima permite exportar um serviço dos clusters membros para o recurso Fleet. Depois de exportado com êxito, o serviço e todos os seus pontos de extremidade são sincronizados com o cluster de frota e podem ser usados para configurar o balanceamento de carga de vários clusters entre esses pontos de extremidade. A saída é semelhante ao exemplo a seguir:
```
deployment.apps/kuard created
service/kuard created
serviceexport.networking.fleet.azure.com/kuard created
```

Crie o seguinte ClusterResourcePlacement em um arquivo chamado crp-2.yaml. Observe que estamos selecionando clusters na eastus região:

apiVersion: placement.kubernetes-fleet.io/v1
kind: ClusterResourcePlacement
metadata:
  name: kuard-demo
spec:
  resourceSelectors:
    - group: ""
      version: v1
      kind: Namespace
      name: kuard-demo
  policy:
    affinity:
      clusterAffinity:
        requiredDuringSchedulingIgnoredDuringExecution:
          clusterSelectorTerms:
            - labelSelector:
                matchLabels:
                  fleet.azure.com/location: eastus

Aplique o ClusterResourcePlacement:

KUBECONFIG=fleet kubectl apply -f crp-2.yaml

Se for bem-sucedida, a saída será semelhante ao exemplo a seguir:

clusterresourceplacement.placement.kubernetes-fleet.io/kuard-demo created

Verifique o estado do ClusterResourcePlacement:

KUBECONFIG=fleet kubectl get clusterresourceplacements

Se for bem-sucedida, a saída será semelhante ao exemplo a seguir:

NAME            GEN   SCHEDULED   SCHEDULEDGEN   APPLIED   APPLIEDGEN   AGE
kuard-demo      1     True        1              True      1            20s

Criar MultiClusterService para balancear a carga entre os pontos de extremidade de serviço em vários clusters membros

Verifique se o serviço foi exportado com êxito para os clusters membros na eastus região:
```
KUBECONFIG=aks-member-1 kubectl get serviceexport kuard --namespace kuard-demo
```
A saída é semelhante ao exemplo a seguir:
```
NAME    IS-VALID   IS-CONFLICTED   AGE
kuard   True       False           25s
```
```
KUBECONFIG=aks-member-2 kubectl get serviceexport kuard --namespace kuard-demo
```
A saída é semelhante ao exemplo a seguir:
```
NAME    IS-VALID   IS-CONFLICTED   AGE
kuard   True       False           55s
```
Você deve ver que o serviço é válido para exportação (IS-VALID campo é true) e não tem conflitos com outras exportações (IS-CONFLICT é false).

Nota

Pode levar um ou dois minutos para que o ServiceExport seja propagado.

Crie MultiClusterService num membro para equilibrar a carga entre os endpoints de serviço nestes clusters:

KUBECONFIG=aks-member-1 kubectl apply -f https://raw.githubusercontent.com/Azure/AKS/master/examples/fleet/kuard/kuard-mcs.yaml

Nota

Para expor o serviço através do IP interno em vez de público, adicione a anotação ao MultiClusterService:

apiVersion: networking.fleet.azure.com/v1alpha1
kind: MultiClusterService
metadata:
  name: kuard
  namespace: kuard-demo
  annotations:
     networking.fleet.azure.com/azure-load-balancer-internal: "true"
  ...

A saída é semelhante ao exemplo a seguir:

multiclusterservice.networking.fleet.azure.com/kuard created

Verifique se o MultiClusterService é válido executando o seguinte comando:
```
KUBECONFIG=aks-member-1 kubectl get multiclusterservice kuard --namespace kuard-demo
```
O resultado deverá ter um aspeto semelhante ao seguinte exemplo:
```
NAME    SERVICE-IMPORT   EXTERNAL-IP     IS-VALID   AGE
kuard   kuard            <a.b.c.d>       True       40s
```
O IS-VALID campo deve estar true na saída. Verifique o endereço IP do balanceador de carga externo (EXTERNAL-IP) na saída. Pode demorar algum tempo até que a importação seja totalmente processada e o endereço IP fique disponível.
Execute o seguinte comando várias vezes usando o endereço IP do balanceador de carga externo:
```
curl <a.b.c.d>:8080 | grep addrs 
```
Observe que os IPs dos pods que atendem à solicitação estão a mudar e que estes pods são dos clusters de membros aks-member-1 e aks-member-2 na região eastus. Você pode verificar os IPs do pod executando os seguintes comandos nos clusters da eastus região:
```
KUBECONFIG=aks-member-1 kubectl get pods -n kuard-demo -o wide
```
```
KUBECONFIG=aks-member-2 kubectl get pods -n kuard-demo -o wide
```

Feedback

Esta página foi útil?

Last updated on 2025-04-09