Como rotear o tráfego de cargas de trabalho do Cloud Service Mesh para uma VM do Compute Engine

Esta página mostra como rotear o tráfego de rede com segurança de cargas de trabalho do Cloud Service Mesh no GKE para uma VM do Compute Engine com um BackendService.

Ao rotear o tráfego do GKE para uma VM do Compute Engine, não é necessário que a VM ou o BackendService do Compute Engine entre no Cloud Service Mesh. No entanto, a VM do Compute Engine e o BackendService precisam estar no mesmo projeto que o cluster do GKE do Cloud Service Mesh. Essa limitação existe enquanto o recurso estiver disponível no pré-lançamento público. O MTLS não é compatível com VMs do Compute Engine.

Antes de começar

As seções a seguir consideram que você tem:

  1. Um cluster do GKE com o Cloud Service Mesh ativado.
  2. Uma VM do Compute Engine implantada com um BackendService.

Como alternativa, execute os comandos a seguir para implantar uma VM de amostra do Compute Engine com um BackendService.

  1. Implante uma VM de amostra do Compute Engine e um BackendService:

    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

    Em que:

    • VM_ZONE é a zona em que você quer que a VM do Compute Engine seja implantada.

Configurar uma VM do Compute Engine como um GCPBackend

Nesta seção, você expõe a VM do Compute Engine às cargas de trabalho do GKE usando o GCPBackend. O GCPBackend consiste em:

  1. Informações de front-end: especificamente, o nome do host e a porta que as cargas de trabalho do GKE usariam para chamar esse GCPBackend.
  2. Informações de back-end: os detalhes do BackendService, como nome do serviço, local e número do projeto.

O GCPBackend contém o nome do host e os detalhes da porta, bem como os detalhes do BackendService (nome do serviço, local e número do projeto). As cargas de trabalho do GKE precisam usar o nome do host e a porta do GCPBackend nas solicitações HTTP para acessar a VM do Compute Engine.

Para que o nome do host seja resolvido pelo DNS no cluster (por padrão, ele não é resolvível), configure Google Cloud o DNS para resolver todos os hosts em um nome de host escolhido para um endereço IP arbitrário. Até que você configure essa entrada de DNS, a solicitação falhará. A configuração do Google Cloud DNS é uma configuração única por domínio personalizado.

  1. Crie uma zona gerenciada:

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

    Neste exemplo, o nome DNS é gcpbackend e a rede VPC é default.

  2. Configure o registro para tornar o domínio resolvível:

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

  3. Crie o GCPBackend com um nome de host no domínio anterior:

    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

    Neste exemplo, GCP_BACKEND_NAME é vm-gcp-backend.

  4. Crie um pod de teste para verificar a conectividade da VM do GKE com o 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

    Agora, as cargas de trabalho do GKE podem acessar a VM do Compute Engine enviando solicitações HTTP para hello-world.gcpbackend:80.

Use nomes distintos para o GCPBackend para evitar conflitos com os serviços do Kubernetes ou as entradas de serviço do Istio. Se houver conflito, a ordem de precedência (de alta a baixa) será Serviço do Kubernetes, ServiceEntry do Istio e GCPBackend.

Observação: o serviço virtual e o GCPBackend precisam estar no mesmo namespace, e a VM do Compute Engine precisa estar no mesmo projeto que o cluster do GKE do Cloud Service Mesh.