Instradare il traffico dai carichi di lavoro Cloud Service Mesh alla VM Compute Engine

Questa pagina mostra come instradare in modo sicuro il traffico di rete dai carichi di lavoro Cloud Service Mesh su GKE alla VM Compute Engine front-end di un BackendService.

Tieni presente che quando instradi il traffico da GKE a una VM Compute Engine, non è necessario che la VM Compute Engine o BackendService si unisca a Cloud Service Mesh. Tuttavia, la VM Compute Engine e BackendService devono trovarsi nello stesso progetto del cluster GKE di Cloud Service Mesh. Questa limitazione esiste finché questa funzionalità è disponibile in anteprima pubblica. MTLS non è supportato per le VM di Compute Engine

Prima di iniziare

Le seguenti sezioni presuppongono che tu disponga di quanto segue:

  1. Un cluster GKE con Cloud Service Mesh abilitato.
  2. È stato eseguito il deployment di una VM di Compute Engine front-end di un BackendService.

In alternativa, puoi eseguire i seguenti comandi per eseguire il deployment di una VM di Compute Engine di esempio front-end di un BackendService.

  1. Esegui il deployment di una VM di Compute Engine e di un BackendService di esempio:

    gcloud compute instance-templates create td-httpd-vm-template \
  --scopes=https://www.googleapis.com/auth/cloud-platform \
  --tags=http-td-server \
  --image-family=debian-11 \
  --image-project=debian-cloud \
  --metadata=startup-script="#! /bin/bash
sudo apt-get update -y
sudo apt-get install apache2 -y
sudo service apache2 restart
echo '<!doctype <html><body><h1>'\`$(/bin/hostname)\`'</h1></body></html>' | sudo tee /var/www/html/index.html"

gcloud compute instance-groups managed create http-td-mig-us-east1 \
  --zone=VM_ZONE   \
  --size=2 \
  --template=td-httpd-vm-template

gcloud compute health-checks create http http-helloworld-health-check

gcloud compute firewall-rules create http-vm-allow-health-checks \
  --network=default \
  --action=ALLOW \
  --direction=INGRESS \
  --source-ranges=0.0.0.0/0 \
  --target-tags=http-td-server \
  --rules=tcp:80

gcloud compute backend-services create helloworld \
  --global \
  --load-balancing-scheme=INTERNAL_SELF_MANAGED \
  --protocol=HTTP \
  --health-checks http-helloworld-health-check

gcloud compute backend-services add-backend helloworld \
  --instance-group=http-td-mig-us-east1 \
  --instance-group-zone=VM_ZONE  \
  --global

    Dove:

    • VM_ZONE è la zona in cui vuoi che venga eseguito il deployment della VM Compute Engine.

Configura una VM di Compute Engine come GCPBackend

In questa sezione, esponi la VM Compute Engine ai carichi di lavoro GKE utilizzando GCPBackend. GCPBackend è composto da:

  1. Informazioni sul frontend, in particolare l'hostname e la porta che i carichi di lavoro GKE utilizzerebbero per chiamare questo GCPBackend.
  2. Informazioni di backend: i dettagli di BackendService, come nome del servizio, posizione e numero di progetto.

GCPBackend contiene i dettagli del nome host e della porta, nonché i dettagli di BackendService (nome del servizio, posizione e numero di progetto). I workload GKE devono utilizzare il nome host e la porta GCPBackend nelle richieste HTTP per accedere alla VM di Compute Engine.

Per rendere il DNS del nome host risolvibile all'interno del cluster (per impostazione predefinita non è risolvibile), devi configurare Google Cloud DNS in modo che risolva tutti gli host in un nome host scelto in un indirizzo IP arbitrario. Finché non configuri questa voce DNS, la richiesta non va a buon fine. La Google Cloud configurazione DNS è una configurazione una tantum per ogni dominio personalizzato.

  1. Crea una zona gestita:

    gcloud dns managed-zones create prod \
    --description="zone for gcpbackend" \
    --dns-name=gcpbackend \
    --visibility=private \
    --networks=default

    In questo esempio, il nome DNS è gcpbackend e la rete VPC è default.

  2. Configura il record per rendere risolvibile il dominio:

    gcloud beta dns record-sets create *.gcpbackend \
  --ttl=3600 --type=A --zone=prod \
  --rrdatas=10.0.0.1

  3. Crea GCPBackend con un nome host nel dominio precedente:

    cat <<EOF > gcp-backend.yaml
apiVersion: networking.gke.io/v1
kind: GCPBackend
metadata:
  name: vm-gcp-backend
  namespace: NAMESPACE
spec:
  type: "BackendService"
  hostname: hello-world.gcpbackend
  backendservice:
    name: helloworld
    location: global
EOF
kubectl apply -f gcp-backend.yaml

    In questo esempio, GCP_BACKEND_NAME è vm-gcp-backend.

  4. Crea un pod di test per verificare la connettività da GKE alla VM di Compute Engine:

    cat <<EOF | kubectl apply -f -
apiVersion: v1
kind: Pod
metadata:
  name: testcurl
  namespace: default
spec:
  containers:
  - name: curl
    image: curlimages/curl
    command: ["sleep", "3000"]
EOF

kubectl exec testcurl -c curl -- curl http://hello-world.gcpbackend:80

    Ora, i tuoi carichi di lavoro GKE possono accedere alla VM Compute Engine inviando richieste HTTP a hello-world.gcpbackend:80.

Devi utilizzare nomi distinti per GCPBackend per evitare conflitti con i servizi Kubernetes o le voci di servizio Istio esistenti. In caso di conflitto, l'ordine di precedenza (da alto a basso) è Kubernetes Service, istio ServiceEntry e GCPBackend.

Tieni presente che il servizio virtuale e GCPBackend devono trovarsi nello stesso spazio dei nomi e la VM Compute Engine deve trovarsi nello stesso progetto del cluster GKE di Cloud Service Mesh.