Configura un mesh di servizi collaterali Envoy

Questa configurazione è supportata per i clienti del servizio Anteprima, ma è sconsigliata per i nuovi utenti di Cloud Service Mesh. Per saperne di più, consulta la panoramica di Cloud Service Mesh.

Questa guida illustra come configurare un semplice mesh di servizi nel tuo fleet. La guida prevede i seguenti passaggi:

  • Esegui il deployment dell'iniettore di sidecar Envoy nel cluster. Iniettore inserisce il container proxy Envoy nei pod dell'applicazione.
  • Esegui il deployment di risorse API Gateway che configurano il sidecar Envoy nel mesh di servizi per instradare le richieste a un servizio di esempio nello spazio dei nomi store.
  • Deployment di un client semplice per verificare il deployment.

Il seguente diagramma mostra il mesh di servizi configurato.

Un mesh di servizi sidecar Envoy in un parco risorse
Un mesh di servizi sidecar Envoy in un parco risorse (fai clic per ingrandire)

Puoi configurare un solo Mesh in un cluster, perché il nome del mesh nella configurazione dell'iniettore sidecar e il nome della risorsa Mesh devono essere identici.

Esegui il deployment dell'iniettore sidecar Envoy

Per eseguire il deployment dell'iniettore sidecar, devi fornire due valori.

  • TRAFFICDIRECTOR_GCP_PROJECT_NUMBER. Sostituisci PROJECT_NUMBER con il numero del progetto per il cluster di configurazione. Il numero del progetto è l'identificatore numerico del progetto.

  • TRAFFICDIRECTOR_MESH_NAME. Assegna il valore come segue, dove MESH_NAME è il valore del campo metadata.name nella specifica della risorsa Mesh:

    gketd-MESH_NAME

    Ad esempio, se il valore di metadata.name nella risorsa Mesh è butterfly-mesh, imposta il valore di TRAFFICDIRECTOR_MESH_NAME come segue:

    TRAFFICDIRECTOR_MESH_NAME: "gketd-butterfly-mesh"

  • TRAFFICDIRECTOR_NETWORK_NAME. Assicurati che il valore Il campo TRAFFICDIRECTOR_NETWORK_NAME è vuoto:

    TRAFFICDIRECTOR_NETWORK_NAME=""

  1. Scarica il pacchetto di iniettori collaterali:

    wget https://storage.googleapis.com/traffic-director/td-sidecar-injector-xdsv3.tgz
tar -xzvf td-sidecar-injector-xdsv3.tgz
cd td-sidecar-injector-xdsv3

  2. Nel file specs/01-configmap.yaml, compila i campi TRAFFICDIRECTOR_GCP_PROJECT_NUMBER e TRAFFICDIRECTOR_MESH_NAME e imposta TRAFFICDIRECTOR_NETWORK_NAME su vuoto.

        apiVersion: v1
    kind: ConfigMap
    metadata:
      name: istio
      namespace: istio-system
    data:
      mesh: |-
        defaultConfig:
          discoveryAddress: trafficdirector.googleapis.com:443

          # Envoy proxy port to listen on for the admin interface.
          # This port is bound to 127.0.0.1.
          proxyAdminPort: 15000

          proxyMetadata:
            # Google Cloud Project number that your Fleet belongs to.
            # This is the numeric identifier of your project
            TRAFFICDIRECTOR_GCP_PROJECT_NUMBER: "PROJECT_NUMBER"

            # TRAFFICDIRECTOR_NETWORK_NAME must be empty when
            # TRAFFICDIRECTOR_MESH_NAME is set.
            TRAFFICDIRECTOR_NETWORK_NAME: "NETWORK_NAME"

            # The value of `metadata.name` in the `Mesh` resource. When a
            # sidecar requests configurations from Cloud Service Mesh,
            # Cloud Service Mesh will only return configurations for the
            # specified mesh.
            TRAFFICDIRECTOR_MESH_NAME: "gketd-td-mesh"

Dopo aver completato le istruzioni precedenti, segui questi passaggi per eseguire il deployment dell'iniettore sidecar nel cluster:

  1. Configurazione di TLS per l'iniettore sidecar.
  2. Installazione dell'injector collaterale nel cluster GKE.
  3. [Facoltativo] Apertura della porta richiesta su un cluster privato.
  4. Attiva l'iniezione sidecar.

Esegui il deployment del servizio store

In questa sezione eseguirai il deployment del servizio store nel mesh.

  1. Nel file store.yaml, salva il seguente manifest:

    kind: Namespace
apiVersion: v1
metadata:
  name: store
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: store
  namespace: store
spec:
  replicas: 2
  selector:
    matchLabels:
      app: store
      version: v1
  template:
    metadata:
      labels:
        app: store
        version: v1
    spec:
      containers:
      - name: whereami
        image: gcr.io/google-samples/whereami:v1.2.20
        ports:
        - containerPort: 8080
---
apiVersion: v1
kind: Service
metadata:
  name: store
  namespace: store
spec:
  selector:
    app: store
  ports:
  - port: 8080
    targetPort: 8080

  2. Applica il manifest a gke-1:

    kubectl apply -f store.yaml

Crea un mesh di servizi

  1. Nel file mesh.yaml, salva il seguente manifest mesh. Il nome della risorsa mesh deve corrispondere al nome del mesh specificato nel ConfigMap dell'iniettore. In questa configurazione di esempio, il nome td-mesh viene utilizzato in entrambi i punti:

    apiVersion: net.gke.io/v1alpha1
kind: TDMesh
metadata:
  name: td-mesh
  namespace: default
spec:
  gatewayClassName: gke-td
  allowedRoutes:
    namespaces:
      from: All

  2. Applica il manifest mesh a gke-1, in modo da creare una mesh logica con il nome td-mesh:

    kubectl apply -f mesh.yaml

  3. Nel file store-route.yaml, salva quanto segue: HTTPRoute del file manifest. Il manifest definisce una risorsa HTTPRoute che instrada il traffico HTTP specificando il nome host example.com a un servizio Kubernetes store nello spazio dei nomi store:

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

  4. Applica il manifest della route a gke-1:

    kubectl apply -f store-route.yaml

Convalida il deployment

  1. Controlla lo stato e gli eventi di Mesh per verificare che le risorse Mesh e HTTPRoute siano state implementate correttamente:

    kubectl describe tdmesh td-mesh

    L'output è simile al seguente:

    ...

Status:
  Conditions:
    Last Transition Time:  2022-04-14T22:08:39Z
    Message:
    Reason:                MeshReady
    Status:                True
    Type:                  Ready
    Last Transition Time:  2022-04-14T22:08:28Z
    Message:
    Reason:                Scheduled
    Status:                True
    Type:                  Scheduled
Events:
  Type    Reason  Age   From                Message
  ----    ------  ----  ----                -------
  Normal  ADD     36s   mc-mesh-controller  Processing mesh default/td-mesh
  Normal  UPDATE  35s   mc-mesh-controller  Processing mesh default/td-mesh
  Normal  SYNC    24s   mc-mesh-controller  SYNC on default/td-mesh was a success

  2. Per assicurarti che l'iniezione di sidecar sia abilitata nel namespace predefinito, esegui il seguente comando:

    kubectl get namespace default --show-labels

    Se l'iniezione sidecar è attivata, nell'output viene visualizzato quanto segue:

    istio-injection=enabled

    Se l'inserimento di file collaterali non è abilitato, consulta Attivare le iniezioni di file collaterali.

  3. Per verificare il deployment, esegui il deployment di un pod client che funga da client al servizio store definito in precedenza. Salva nel file client.yaml le seguenti:

    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

  4. Esegui il deployment della specifica:

    kubectl apply -f client.yaml

    L'injector sidecar in esecuzione nel cluster inserisce automaticamente un Envoy nel pod del client.

  5. Per verificare che il contenitore Envoy sia stato inserito, esegui il seguente comando:

    kubectl describe pods -l run=client

    L'output è simile al seguente:

    ...
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:
...

Una volta eseguito il provisioning del pod del client, invia una richiesta dal pod del client all'account Servizio store.

  1. Ottieni il nome del pod del client:

    CLIENT_POD=$(kubectl get pod -l run=client -o=jsonpath='{.items[0].metadata.name}')

# The VIP where the following request will be sent. Because all requests
# from the client container are redirected to the Envoy proxy sidecar, you
# can use any IP address, including 10.0.0.2, 192.168.0.1, and others.
VIP='10.0.0.1'

  2. Invia una richiesta al servizio di archiviazione e visualizza le intestazioni di risposta:

    TEST_CMD="curl -v -H 'host: example.com' $VIP"

  3. Esegui il comando di test nel container client:

    kubectl exec -it $CLIENT_POD -c client -- /bin/sh -c "$TEST_CMD"

    L'output è simile al seguente:

    < Trying 10.0.0.1:80...
< Connected to 10.0.0.1 (10.0.0.1) port 80 (#0)
< GET / HTTP/1.1
< Host: example.com
< User-Agent: curl/7.82.0-DEV
< Accept: */*
<
< Mark bundle as not supporting multiuse
< HTTP/1.1 200 OK
< content-type: application/json
< content-length: 318
< access-control-allow-origin: *
< server: envoy
< date: Tue, 12 Apr 2022 22:30:13 GMT
<
{
  "cluster_name": "gke-1",
  "zone": "us-west1-a",
  "host_header": "example.com",
  ...
}

Passaggi successivi