Manage multi-cluster services from the command line to enable cross-cluster access for Kubernetes services - Container Service for Kubernetes: Central de Documentação do Alibaba Cloud

O Multi-cluster Services (MCS) permite que pods em um cluster ACK acessem Services executados em outro cluster sem a necessidade de criar um balanceador de carga. Você exporta um Service do cluster provedor usando um resource ServiceExport, e a instância Fleet sincroniza automaticamente as informações de endpoint com o cluster consumidor. Em seguida, crie um ServiceImport no cluster consumidor para tornar o Service exportado acessível.

Pré-requisitos

Antes de começar, verifique se você tem:

Gerenciamento de Fleet ativado. Consulte Enable multi-cluster management.
Dois clusters associados à instância Fleet: um cluster provedor de serviços (ACK Cluster 1) e um cluster consumidor de serviços (ACK Cluster 2). Consulte Associate clusters with a Fleet instance.
Kubernetes 1.22 ou posterior em ambos os clusters.
Arquivos kubeconfig para ambos os clusters, com kubectl configurado para se conectar a cada um. Consulte Obtain the kubeconfig file of a cluster and use kubectl to connect to the cluster.

Como funciona

Multi-cluster Services architecture

O administrador implanta namespaces, Deployments e Services no cluster provedor (ACK Cluster 1) e no cluster consumidor (ACK Cluster 2), além de criar resources MCS, incluindo um ServiceExport e um ServiceImport.
A instância Fleet monitora o ServiceExport e o ServiceImport nos clusters ACK associados e sincroniza as informações de endpoint do MCS.
Os pods no ACK Cluster 2 conseguem acessar o Service 1 no ACK Cluster 1.

Etapa 1: Configure o cluster provedor

Ignore esta etapa se o Service e seus resources já existirem no ACK Cluster 1.

Crie um namespace no ACK Cluster 1:
```
kubectl create ns provider-ns
```

Crie um arquivo chamado app-meta.yaml com o seguinte conteúdo:

apiVersion: v1
kind: Service
metadata:
  name: service1
  namespace: provider-ns
spec:
  ports:
  - name: http
    port: 80
    protocol: TCP
    targetPort: 8080
  selector:
    app: web-demo
  sessionAffinity: None
  type: ClusterIP
---
apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    app: web-demo
  name: web-demo
  namespace: provider-ns
spec:
  replicas: 2
  selector:
    matchLabels:
      app: web-demo
  template:
    metadata:
      labels:
        app: web-demo
    spec:
      containers:
      - image: acr-multiple-clusters-registry.cn-hangzhou.cr.aliyuncs.com/ack-multiple-clusters/web-demo:0.4.0
        name: web-demo
        env:
        - name: ENV_NAME
          value: cluster1-beijing

Aplique o manifesto no ACK Cluster 1:
```
kubectl apply -f app-meta.yaml
```

Crie um arquivo chamado service-export.yaml com o seguinte conteúdo:

apiVersion: multicluster.x-k8s.io/v1alpha1
kind: ServiceExport
metadata:
  name: service1         # Must match the name of the Service to export.
  namespace: provider-ns # Must match the namespace of the Service to export.

Aplique o ServiceExport no ACK Cluster 1:
```
kubectl apply -f service-export.yaml
```

Etapa 2: Configure o cluster consumidor

Crie o mesmo namespace no ACK Cluster 2:
```
kubectl create ns provider-ns
```

Crie um arquivo chamado service-import.yaml com o seguinte conteúdo:

apiVersion: multicluster.x-k8s.io/v1alpha1
kind: ServiceImport
metadata:
  name: service1         # Must match the name of the exported Service.
  namespace: provider-ns # Must match the namespace of the exported Service.
spec:
  ports:
  - name: http
    port: 80
    protocol: TCP
  type: ClusterSetIP

Os parâmetros de spec estão descritos na tabela a seguir:

Parâmetro	Descrição
`metadata.name`	Nome do Service. Deve corresponder ao nome do Service exportado.
`metadata.namespace`	Namespace. Deve corresponder ao namespace do Service exportado.
`spec.ports.name`	Nome da porta. Precisa ser igual ao do Service exportado.
`spec.ports.protocol`	Protocolo utilizado. Necessário coincidir com o Service exportado.
`spec.ports.appProtocol`	Protocolo da aplicação. Deve ser idêntico ao do Service exportado.
`spec.ports.port`	Número da porta. Tem que corresponder ao Service exportado.
`spec.ips`	Endereço IP virtual. Definido pela instância Fleet — deixe este campo em branco.
`spec.type`	Valores válidos: `ClusterSetIP` e `Headless`. Utilize `Headless` quando o Service de origem tiver `ClusterIP: None`. Use `ClusterSetIP` em todos os outros casos.
`spec.sessionAffinity`	Afinidade de sessão. Opções válidas: `ClientIP` e `None`. Obrigatório corresponder ao Service exportado.
`spec.sessionAffinityConfig`	Configuração de afinidade de sessão. Deve ser igual à do Service exportado.

Aplique o ServiceImport no ACK Cluster 2:
```
kubectl apply -f service-import.yaml
```

Etapa 3: Acesse o Service entre clusters

Após a criação do ServiceImport, a instância Fleet cria automaticamente um Service multicluster com o prefixo amcs- no ACK Cluster 2. É possível acessar o Service 1 no ACK Cluster 1 usando o nome do Service ou um nome de domínio.

Método 1: Use o nome do Service

Consulte os Services no ACK Cluster 2 para confirmar que o Service amcs-service1 foi criado:

kubectl get service -n provider-ns

Saída esperada:

NAME            TYPE        CLUSTER-IP     EXTERNAL-IP   PORT(S)   AGE
amcs-service1   ClusterIP   172.xx.xx.xx   <none>        80/TCP    26m

A partir de um pod no ACK Cluster 2, execute:
```
curl amcs-service1.provider-ns
```

Método 2: Use um nome de domínio

Instale ou atualize o CoreDNS no ACK Cluster 2. A versão do CoreDNS deve ser 1.9.3 ou posterior. Para mais informações, consulte CoreDNS e Manage components.
Abra o ConfigMap do CoreDNS para edição no ACK Cluster 2:
```
kubectl edit configmap coredns -n kube-system
```

No campo Corefile, adicione multicluster clusterset.local para ativar a resolução de nomes de domínio para Services multicluster:

apiVersion: v1
data:
  Corefile: |
    .:53 {
        errors
        health {
           lameduck 15s
        }
        ready
        multicluster clusterset.local    # Add this line.
        kubernetes cluster.local in-addr.arpa ip6.arpa {
          pods verified
          ttl 30
          fallthrough in-addr.arpa ip6.arpa
        }
        ...
    }
kind: ConfigMap
metadata:
  name: coredns
  namespace: kube-system

A partir de um pod no ACK Cluster 2, execute:

curl service1.provider-ns.svc.clusterset.local

(Opcional) Para usar uma URL mais curta, adicione clusterset.local ao campo dnsConfig.searches do pod cliente:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: client-pod
  namespace: consumer-ns
spec:
  ...
  template:
    ...
    spec:
      dnsPolicy: "ClusterFirst"
      dnsConfig:
        searches:
          - svc.clusterset.local
          - clusterset.local
          - consumer-ns.svc.cluster.local
          - svc.cluster.local
          - cluster.local
      containers:
      - name: client-pod
        ...

Depois de aplicar essa configuração, utilize a forma abreviada:

curl service1.provider-ns

Próximos passos

Também é possível configurar o MCS no console do ACK One. Consulte Use MCS in the ACK One console.

Referências

Gerenciar serviços multicluster no console