O Anthos Service Mesh e o Traffic Director agora são Cloud Service Mesh. Para mais informações, consulte a Visão geral do Cloud Service Mesh.

Esta página foi traduzida pela API Cloud Translation.

Configurar uma malha de serviço de vários clusters

Esta configuração é compatível com clientes de pré-lançamento, mas não recomendamos para novos usuários do Cloud Service Mesh. Para mais informações, consulte a Visão geral do Cloud Service Mesh.

Este guia mostra como adicionar um novo cluster do GKE a uma malha de serviço atual.

Antes de começar

Antes de adicionar um cluster, conclua as instruções em Preparar para implantar com a API GKE Gateway, incluindo Ativar serviços de vários clusters.

Criar um novo cluster do GKE

Crie um novo cluster usando o seguinte comando:

gcloud container clusters create gke-2 \
  --zone=us-west1-a \
  --enable-ip-alias \
  --workload-pool=PROJECT_ID.svc.id.goog \
  --scopes=https://www.googleapis.com/auth/cloud-platform \
  --release-channel regular \
  --project=PROJECT_ID

Mude para o cluster que você acabou de criar emitindo o comando a seguir:
```
gcloud container clusters get-credentials gke-2 --zone us-west1-a
```

Renomeie o contexto do cluster:

kubectl config rename-context gke_PROJECT_ID_us-west1-a_gke-2 gke-2

Registrar o cluster em uma frota

Após a criação do cluster, registre-o na sua frota:

gcloud alpha container hub memberships register gke-2 \
  --gke-cluster us-west1-a/gke-2 \
  --enable-workload-identity \
  --project=PROJECT_ID

Verifique se os clusters estão registrados na frota:

gcloud alpha container hub memberships list --project=PROJECT_ID

O Fleet inclui o cluster que você acabou de criar e o cluster criado anteriormente:

NAME          EXTERNAL_ID
gke-1  657e835d-3b6b-4bc5-9283-99d2da8c2e1b
gke-2  f3727836-9cb0-4ffa-b0c8-d51001742f19

Implantar o injetor do arquivo secundário do Envoy no novo cluster do GKE

Siga as instruções para implantar o injetor do arquivo secundário do Envoy e implantar o injetor no cluster gke-2.

Expandir a malha de serviço para o novo cluster do GKE

O guia Implantar uma malha de serviço secundário do Envoy mostra como configurar uma malha de serviço no cluster gke-1, em que o serviço store é executado. Esta seção mostra como expandir a malha de serviço para incluir um serviço payments em execução no cluster gke-2. Como um recurso Mesh já existe no cluster de configuração, não é necessário criar um recurso Mesh no novo cluster.

Implantar o serviço `payments`

No arquivo payments.yaml, salve o seguinte manifesto:

kind: Namespace
apiVersion: v1
metadata:
  name: payments
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: payments
  namespace: payments
spec:
  replicas: 2
  selector:
    matchLabels:
      app: payments
      version: v1
  template:
    metadata:
      labels:
        app: payments
        version: v1
    spec:
      containers:
      - name: whereami
        image: us-docker.pkg.dev/google-samples/containers/gke/whereami:v1.2.20
        ports:
        - containerPort: 8080
---
apiVersion: v1
kind: Service
metadata:
  name: payments
  namespace: payments
spec:
  selector:
    app: payments
  ports:
  - port: 8080
    targetPort: 8080

Aplique o manifesto ao cluster gke-2:

kubectl apply --context gke-2 -f payments.yaml

Exportar o serviço `payments`

Todos os recursos da API Gateway são armazenados centralmente no cluster de configuração gke-1. Os serviços em outros clusters na frota precisam ser exportados para que os recursos da API Gateway no cluster gke-1 possam referenciá-los quando você configurar o comportamento de rede da malha de serviço.

Para uma explicação detalhada de como ServiceExport e ServiceImport funcionam, leia Serviços de vários clusters.

Crie o namespace payments no cluster gke-1. O serviço payments no cluster gke-1 é exportado para todos os clusters na frota que estão no mesmo namespace.
```
kubectl create namespace payments --context gke-1
```

No arquivo export-payments.yaml, salve o seguinte manifesto:

kind: ServiceExport
apiVersion: net.gke.io/v1
metadata:
  name: payments
  namespace: payments

Aplique o manifesto ServiceExport no cluster gke-2:

kubectl apply --context gke-2 -f export-payments.yaml

Após alguns minutos, execute o seguinte comando para verificar se o serviceImports complementar foi criado pelo controlador de serviços de vários clusters em gke-1:
```
kubectl get serviceimports --context gke-1 --namespace payments
```
A saída será semelhante a esta:
```
NAME           TYPE           IP                  AGE
payments       ClusterSetIP   ["10.112.31.15"]    6m54s
```

Configurar um recurso `HTTPRoute` para o serviço `payments`

No arquivo payments-route.yaml, salve o seguinte manifesto HTTPRoute:

apiVersion: gateway.networking.k8s.io/v1alpha2
kind: HTTPRoute
metadata:
  name: payments-route
  namespace: payments
spec:
  parentRefs:
  - name: td-mesh
    namespace: default
    group: net.gke.io
    kind: TDMesh
  hostnames:
  - "example.com"
  rules:
  - matches:
    - path:
        type: PathPrefix
        value: /payments
    backendRefs:
    - group: net.gke.io
      kind: ServiceImport
      namespace: payments
      name: payments
      port: 8080

Aplique o manifesto do trajeto a gke-1:

kubectl apply --context gke-1 -f payments-route.yaml

Validar a implantação

Inspecione o status e os eventos de Mesh para verificar se Mesh e HTTPRoute foram implantados corretamente.

Execute este comando:

kubectl describe tdmesh td-mesh -–context gke-1

A saída será semelhante a:

...
Status:
  Conditions:
    Last Transition Time:  2022-04-14T22:49:56Z
    Message:
    Reason:                MeshReady
    Status:                True
    Type:                  Ready
    Last Transition Time:  2022-04-14T22:27:17Z
    Message:
    Reason:                Scheduled
    Status:                True
    Type:                  Scheduled
Events:
  Type    Reason  Age                From                Message
  ----    ------  ----               ----                -------
  Normal  ADD     23m                mc-mesh-controller  Processing mesh default/td-mesh
  Normal  UPDATE  23m                mc-mesh-controller  Processing mesh default/td-mesh
  Normal  SYNC    23m                mc-mesh-controller  Processing mesh default/td-mesh
  Normal  SYNC    71s                mc-mesh-controller  SYNC on default/td-mesh was a success

Para verificar a implantação, implante um pod cliente em um dos clusters. No arquivo client.yaml, salve o seguinte:

apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    run: client
  name: client
  namespace: default
spec:
  replicas: 1
  selector:
    matchLabels:
      run: client
  template:
    metadata:
      labels:
        run: client
    spec:
      containers:
      - name: client
        image: curlimages/curl
        command:
        - sh
        - -c
        - while true; do sleep 1; done

Aplique o manifesto:
```
kubectl apply -f client.yaml --context $CLUSTER
```
O injetor secundário em execução no cluster injeta automaticamente um contêiner do Envoy no pod cliente.

Para verificar se o contêiner do Envoy foi injetado, execute o seguinte comando:

kubectl describe pods -l run=client --context $CLUSTER

A saída será assim:

...
Init Containers:
  # Istio-init sets up traffic interception for the Pod.
  istio-init:
...
  # td-bootstrap-writer generates the Envoy bootstrap file for the Envoy container
  td-bootstrap-writer:
...
Containers:
# client is the client container that runs application code.
  client:
...
# Envoy is the container that runs the injected Envoy proxy.
  envoy:
...

Depois que o mesh e o pod cliente forem provisionados, envie uma solicitação do pod cliente para o serviço store:

# Get the name of the client Pod.
CLIENT_POD=$(kubectl get pod --context $CLUSTER -l run=client -o=jsonpath='{.items[0].metadata.name}')

# The VIP where the following request will be sent. Because requests from the
# Busybox container are redirected to the Envoy proxy, the IP address can
# be any other address, such as 10.0.0.2 or 192.168.0.1.
VIP='10.0.0.1'

# Command to send a request to store.
TEST_CMD="curl -v -H 'Host: example.com' $VIP/store"

# Execute the test command in the client container.
kubectl exec -it $CLIENT_POD -c client --context $CLUSTER -- /bin/sh -c "$TEST_CMD"

A resposta mostrará que um dos pods store em gke-1 atende à solicitação:

{
  "cluster_name": "gke-1",
  "zone": "us-central1-a",
  "host_header": "example.com",
...
}

Envie uma solicitação para o serviço payments:

# Command to send a request to payments.
TEST_CMD="curl -v -H 'host: example.com' $VIP/payments"

# Execute the test command in the client container.
kubectl exec -it $CLIENT_POD -c client -- /bin/sh -c "$TEST_CMD"

A resposta mostrará que um dos pods payments no gke-2 atende à solicitação:

{
  "cluster_name": "gke-2",
  "zone": "us-west1-a",
  "host_header": "example.com",
...
}

A seguir

Saiba como resolver problemas com sua implantação.