Configurazione di Traffic Director per un gateway in entrata

Questa guida illustra come configurare Traffic Director con un gateway in entrata.

In questa configurazione, un bilanciatore del carico di rete indirizza il traffico da Internet al mesh di servizi tramite un gateway in entrata. Una risorsa Gateway gestisce un proxy Envoy che funge da gateway nella rete mesh di servizi. Un gateway è anche noto come traffico in entrata o proxy intermedio. I proxy Envoy di cui è stato eseguito il deployment come gateway in entrata sono proxy autonomi piuttosto che sidecar per un carico di lavoro. In questa modalità, Envoy ascolta un elenco ben definito di indirizzi IP e porte e inoltra il traffico in base alle regole di routing configurate. Per configurare i client Envoy viene utilizzata una nuova risorsa API Gateway.

Gateway in entrata con proxy Envoy, bilanciatore del carico di rete e risorsa gateway
Gateway in entrata con proxy Envoy, bilanciatore del carico di rete e risorsa Gateway (fai clic per ingrandire)

Configura il routing per garantire che il traffico destinato ai proxy Gateway sia indirizzato alle VM che ospitano gli Envoy. Il servizio in entrata può essere accoppiato con un bilanciatore del carico HTTP(S) esterno o con un bilanciatore del carico TCP/UDP interno, ma queste configurazioni non sono incluse in questa configurazione dimostrativa.

Questa guida non illustra la comunicazione service-to-service e la risorsa Mesh dietro il gateway.

Prerequisiti

Assicurati di aver rispettato i prerequisiti nelle seguenti guide:

Configurazione delle regole del firewall

In questa sezione configurerai due regole firewall. Una regola consente i probe del controllo di integrità nella rete Virtual Private Cloud. L'altra regola consente il traffico da qualsiasi origine alla rete.

  1. Configura regole del firewall per consentire i controlli di integrità.

    gcloud compute firewall-rules create allow-gateway-health-checks \
  --network=${VPC_NAME} \
  --direction=INGRESS \
  --action=ALLOW \
  --rules=tcp \
  --source-ranges="35.191.0.0/16,209.85.152.0/22,209.85.204.0/22" \
  --target-tags=gateway-proxy

  2. Configura regole del firewall per consentire il traffico da qualsiasi origine. Modifica i comandi per porte e intervalli di indirizzi IP di origine.

    gcloud compute firewall-rules create allow-gateway-ingress-traffic \
  --network=${VPC_NAME} \
  --direction=INGRESS \
  --action=ALLOW \
  --rules=tcp:80,tcp:443 \
  --source-ranges="0.0.0.0/0" \
  --target-tags=gateway-proxy

Configurazione delle autorizzazioni per Identity and Access Management

In questa sezione devi designare l'account di servizio per i proxy gateway e assegnare loro i ruoli IAM corretti.

  1. Crea un'identità dell'account di servizio per i proxy gateway.

    gcloud iam service-accounts create gateway-proxy

  2. Assegna i ruoli IAM richiesti all'identità dell'account di servizio.

    gcloud projects add-iam-policy-binding ${PROJECT_ID} \
  --member="serviceAccount:gateway-proxy@${PROJECT_ID}.iam.gserviceaccount.com" \
  --role="roles/trafficdirector.client"

    gcloud projects add-iam-policy-binding ${PROJECT_ID} \
  --member="serviceAccount:gateway-proxy@${PROJECT_ID}.iam.gserviceaccount.com" \
  --role="roles/logging.logWriter"

Configurazione della risorsa Gateway

In questa sezione configurerai la risorsa gateway.

  1. In un file denominato gateway80.yaml, crea la specifica Gateway per il traffico HTTP.

    cat <<EOF | tee gateway80.yaml
name: gateway80
scope: gateway-proxy
ports:
- 80
type: OPEN_MESH
EOF

  2. Crea la risorsa Gateway dalla specifica gateway80.yaml:

    gcloud alpha network-services gateways import gateway80 \
    --source=gateway80.yaml \
    --location=global

Creazione di un gruppo di istanze gestite con proxy Envoy

In questa sezione creerai i proxy Envoy associati al gateway in entrata.

  1. Crea un modello di istanza per una VM che esegue un proxy di servizio Envoy con deployment automatico. Gli Envoy hanno un ambito di gateway-proxy. Non trasferire la porta di gestione come parametro --service-proxy.

    gcloud beta compute instance-templates create gateway-proxy \
  --machine-type=n1-standard-1 \
  --boot-disk-size=10GB \
  --scopes=https://www.googleapis.com/auth/cloud-platform \
  --tags=gateway-proxy \
  --network-interface=network=${VPC_NAME},no-address \
  --service-account="gateway-proxy@${PROJECT_ID}.iam.gserviceaccount.com" \
  --service-proxy=enabled,scope=gateway-proxy \

  2. Crea un gruppo di istanze gestite a livello di area geografica dal modello di istanza.

    gcloud compute instance-groups managed create gateway-proxies-${REGION} \
  --region=${REGION} \
  --size=2 \
  --template=gateway-proxy \
  --target-distribution-shape=EVEN

  3. Imposta una porta denominata per attivare il controllo di integrità TCP per il bilanciatore del carico di rete.

    gcloud compute instance-groups managed set-named-ports \
  gateway-proxies-${REGION} \
  --region=${REGION} \
  --named-ports=healthz:80

  4. Abilita la scalabilità automatica per il gruppo di istanze.

    gcloud compute instance-groups managed set-autoscaling \
  gateway-proxies-${REGION} \
  --region=${REGION} \
  --cool-down-period=60 \
  --min-num-replicas=3 \
  --max-num-replicas=10 \
  --mode=on \
  --target-cpu-utilization=0.6

Configurazione del bilanciamento del carico di rete a livello di area geografica

In questa sezione creerai il bilanciatore del carico di rete, un servizio di backend, una regola di forwarding e il controllo di integrità.

  1. Crea il bilanciatore del carico di rete.

    gcloud compute addresses create xnlb-${REGION} \
  --region=${REGION}

  2. Recupera l'indirizzo IP riservato al bilanciatore del carico di rete.

    export IP_ADDRESS=$(gcloud compute addresses describe xnlb-${REGION} \
  --region=${REGION} --format='value(address)')

  3. Crea un controllo di integrità per i proxy gateway.

    gcloud compute health-checks create tcp xnlb-${REGION} \
  --region=${REGION} \
  --port-name=healthz

  4. Crea un servizio di backend per i proxy gateway.

    gcloud compute backend-services create xnlb-${REGION} \
  --health-checks=xnlb-${REGION} \
  --health-checks-region=${REGION} \
  --load-balancing-scheme=EXTERNAL \
  --protocol=TCP \
  --region=${REGION} \
  --port-name=healthz

  5. Aggiungi il gruppo di istanze gestite come backend.

    gcloud compute backend-services add-backend xnlb-${REGION} \
  --instance-group=gateway-proxies-${REGION} \
  --instance-group-region=${REGION} \
  --region=${REGION}

  6. Crea una regola di forwarding che punti ai proxy del gateway.

    gcloud compute forwarding-rules create xnlb-${REGION} \
  --region=${REGION} \
  --load-balancing-scheme=EXTERNAL \
  --address=${IP_ADDRESS} \
  --ip-protocol=TCP \
  --ports=80 \
  --backend-service=xnlb-${REGION} \
  --backend-service-region=${REGION}

Configurazione del server HTTP

In questa sezione creerai un servizio di test nel mesh di servizi.

  1. Crea un modello di istanza con un servizio di test sulla porta 10000 usando l'utilità netcat.

    gcloud compute instance-templates create tcp-td-vm-template \
  --scopes=https://www.googleapis.com/auth/cloud-platform \
  --tags=allow-health-checks \
  --image-family=debian-9 \
  --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><html><body><h1>'\`/bin/hostname\`'</h1></body></html>' | sudo tee /var/www/html/index.html"

  2. Crea un gruppo di istanze gestite basato sul modello.

    gcloud compute instance-groups managed create tcp-td-mig-us-east1 \
  --zone=us-east1-a \
  --size=1 \
  --template=tcp-td-vm-template

  3. Crea un controllo di integrità HTTP.

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

  4. Crea una regola firewall per consentire le connessioni di controllo di integrità in entrata alle istanze nella rete.

    gcloud compute firewall-rules create tcp-vm-allow-health-checks \
   --network default \
   --action allow \
   --direction INGRESS \
   --source-ranges 35.191.0.0/16,209.85.152.0/22,209.85.204.0/22 \
   --target-tags allow-health-checks \
   --rules tcp:80

  5. Crea un servizio di backend globale con uno schema di bilanciamento del carico di INTERNAL_SELF_MANAGED e collega il controllo di integrità.

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

  6. Aggiungi il gruppo di istanze gestite al servizio di backend.

    gcloud compute backend-services add-backend tcp-helloworld-service \
  --instance-group td-mig-us-east1 \
  --instance-group-zone us-east1-a \
  --global

Configurazione del routing con HTTPRoute

Ora hai configurato una risorsa Gateway di Traffic Director e un servizio. Successivamente, connettili utilizzando una risorsa HTTPRoute che associa un nome host a un servizio di backend. Anche HTTPRoute fa riferimento a Gateway.

  1. In un file denominato http_route.yaml, crea la specifica HTTPRoute. La specifica fa riferimento a gateway80, che è la risorsa Gateway creata in precedenza e rimanda al servizio di backend http-helloworld-service.

    name: helloworld-http-route
hostnames:
- helloworld-gce
gateways:
- projects/$PROJECT_NUMBER/locations/global/gateways/gateway80
rules:
- action:
  destinations:
   - serviceName: "projects/$PROJECT_NUMBER/locations/global/backendServices/http-helloworld-service"

  2. Utilizza la specifica in http_route.yaml per creare la risorsa HTTPRoute.

    gcloud alpha network-services http-routes import helloworld-http-route \
    --source=http_route.yaml \
    --location=global

  3. Verifica di poter accedere al servizio da un client esterno tramite il bilanciatore del carico di rete e Traffic Director Gateway.

    curl -H "Host: helloworld-gce" ${IP_ADDRESS}