Encaminhe o tráfego de cargas de trabalho do Cloud Service Mesh para a VM do Compute Engine

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

Tenha em atenção que, ao encaminhar tráfego do GKE para uma VM do Compute Engine, não é necessário que a VM do Compute Engine ou o BackendService se juntem ao Cloud Service Mesh. No entanto, a VM do Compute Engine e o BackendService têm de estar no mesmo projeto que o cluster do GKE do Cloud Service Mesh. Esta limitação existe enquanto esta funcionalidade estiver disponível na pré-visualização pública. O MTLS não é suportado para VMs do Compute Engine

Antes de começar

As secções seguintes pressupõem que:

  1. Um cluster do GKE com o Cloud Service Mesh ativado.
  2. Implementou uma VM do Compute Engine com um BackendService na frente.

Em alternativa, pode executar os seguintes comandos para implementar uma VM do Compute Engine com um BackendService.

  1. Implemente uma VM do Compute Engine e um BackendService de exemplo:

    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

    Onde:

    • VM_ZONE é a zona onde quer que a sua VM do Compute Engine seja implementada.

Configure uma VM do Compute Engine como um GCPBackend

Nesta secção, expõe a VM do Compute Engine aos volumes de trabalho do GKE através do GCPBackend. O GCPBackend é composto por:

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

O GCPBackend contém o nome do anfitrião e os detalhes da porta, bem como os detalhes do BackendService (nome do serviço, localização e número do projeto). As cargas de trabalho do GKE devem usar o nome de anfitrião e a porta do GCPBackend nos respetivos pedidos HTTP para aceder à VM do Compute Engine.

Para tornar o nome do anfitrião resolvível por DNS no cluster (por predefinição, não é resolvível), tem de configurar o DNS para resolver todos os anfitriões sob um nome do anfitrião escolhido para um endereço IP arbitrário. Google Cloud Até configurar esta entrada de DNS, o pedido falha. A configuração de DNS é uma configuração única por domínio personalizado. Google Cloud

  1. Crie uma zona gerida:

    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 registo 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 anfitrião 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 conetividade do GKE à VM do 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 suas cargas de trabalho do GKE podem aceder à VM do Compute Engine enviando pedidos HTTP para hello-world.gcpbackend:80.

Deve usar nomes distintos para o GCPBackend para evitar conflitos com os serviços Kubernetes ou as entradas de serviço do Istio existentes. Se existir um conflito, a ordem de precedência (de alta para baixa) é: serviço Kubernetes, ServiceEntry do Istio e GCPBackend.

Tenha em atenção que o serviço virtual e o GCPBackend têm de estar no mesmo espaço de nomes e que a VM do Compute Engine tem de estar no mesmo projeto que o cluster do GKE do Cloud Service Mesh.