Inoltra il traffico dai carichi di lavoro di 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 con un servizio BackendService.

Tieni presente che, quando indirizzi 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 è valida finché la funzionalità è disponibile in anteprima pubblica. MTLS non è supportato per le VM 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 Compute Engine con un BackendService in primo piano.

In alternativa, puoi eseguire i comandi seguenti per eseguire il deployment di una VM Compute Engine di esempio con un BackendService in primo piano.

  1. Esegui il deployment di una VM 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 eseguire il deployment della VM Compute Engine.

Configura una VM 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 GKE Workloads utilizzerà per chiamare questo GCPBackend.
  2. Informazioni sul backend: i dettagli di BackendService, come nome, posizione e numero del progetto.

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

Per rendere il nome host DNS risolvibile all'interno del cluster (per impostazione predefinita non è risolvibile), devi configurare il DNS in modo che risolva tutti gli host sotto un nome host scelto in un indirizzo IP arbitrario. Google Cloud 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 il dominio risolvibile:

    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à di GKE alla VM 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 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 (dall'alto verso il basso) è Servizio Kubernetes, ServiceEntry di Istio 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 Cloud Service Mesh.