Configura un mesh multi-cluster su Cloud Service Mesh gestito
Questa guida spiega come unire due cluster in un unico Cloud Service Mesh utilizzando Mesh CA o Certificate Authority Service e abilitare il bilanciamento del carico tra cluster. Puoi estendere facilmente questo processo per incorporare qualsiasi numero di cluster nel tuo mesh.
Una configurazione Cloud Service Mesh multi-cluster può risolvere diversi scenari aziendali cruciali, come scalabilità, posizione e isolamento. Per saperne di più, consulta Casi d'uso multi-cluster.
Prerequisiti
Questa guida presuppone che tu abbia due o più cluster GKE Google Cloudche soddisfano i seguenti requisiti:
- Cloud Service Mesh installato sui cluster. Devi avere
asmcli, lo strumentoistioctled esempi cheasmcliscarica nella directory specificata in--output_dir. - Prima di configurare Cloud Service Mesh, i cluster nel mesh devono avere connettività tra tutti i pod. Inoltre, se unisci cluster che non si trovano nello stesso progetto, devono essere registrati nello stesso progetto host del parco risorse e devono trovarsi in una configurazione VPC condiviso insieme sulla stessa rete. Ti consigliamo inoltre di avere un progetto per ospitare il VPC condiviso e due progetti di servizio per la creazione di cluster. Per maggiori informazioni, consulta Configurazione di cluster con VPC condiviso.
- Se utilizzi Certificate Authority Service, tutti i cluster devono avere i rispettivi pool CA subordinati concatenati allo stesso pool CA radice. In caso contrario, dovranno utilizzare tutti lo stesso pool CA.
Impostazione delle variabili di progetto e cluster
Crea le seguenti variabili di ambiente per l'ID progetto, la zona o la regione del cluster, il nome del cluster e il contesto.
export PROJECT_1=PROJECT_ID_1 export LOCATION_1=CLUSTER_LOCATION_1 export CLUSTER_1=CLUSTER_NAME_1 export CTX_1="gke_${PROJECT_1}_${LOCATION_1}_${CLUSTER_1}" export PROJECT_2=PROJECT_ID_2 export LOCATION_2=CLUSTER_LOCATION_2 export CLUSTER_2=CLUSTER_NAME_2 export CTX_2="gke_${PROJECT_2}_${LOCATION_2}_${CLUSTER_2}"Se si tratta di cluster appena creati, assicurati di recuperare le credenziali per ogni cluster con i seguenti comandi
gcloud, altrimenti icontextassociati non saranno disponibili per l'utilizzo nei passaggi successivi di questa guida.I comandi dipendono dal tipo di cluster, a livello di regione o di zona:
Regionale
gcloud container clusters get-credentials ${CLUSTER_1} --region ${LOCATION_1} gcloud container clusters get-credentials ${CLUSTER_2} --region ${LOCATION_2}A livello di zona
gcloud container clusters get-credentials ${CLUSTER_1} --zone ${LOCATION_1} gcloud container clusters get-credentials ${CLUSTER_2} --zone ${LOCATION_2}
Crea regola firewall
In alcuni casi, devi creare una regola firewall per consentire il traffico tra cluster. Ad esempio, devi creare una regola firewall se:
- Utilizzi subnet diverse per i cluster nel mesh.
- I tuoi pod aprono porte diverse da 443 e 15002.
GKE aggiunge automaticamente regole firewall a ogni nodo per consentire il traffico all'interno della stessa subnet. Se il mesh contiene più subnet, devi configurare esplicitamente le regole firewall per consentire il traffico tra subnet. Devi aggiungere una nuova regola firewall per ogni subnet per consentire i blocchi CIDR IP di origine e le porte di destinazione di tutto il traffico in entrata.
Le seguenti istruzioni consentono la comunicazione tra tutti i cluster del tuo progetto o solo tra $CLUSTER_1 e $CLUSTER_2.
Raccogli informazioni sulla rete dei tuoi cluster.
Tutti i cluster del progetto
Se i cluster si trovano nello stesso progetto, puoi utilizzare il seguente comando per consentire la comunicazione tra tutti i cluster del progetto. Se nel tuo progetto sono presenti cluster che non vuoi esporre, utilizza il comando nella scheda Cluster specifici.
function join_by { local IFS="$1"; shift; echo "$*"; } ALL_CLUSTER_CIDRS=$(gcloud container clusters list --project $PROJECT_1 --format='value(clusterIpv4Cidr)' | sort | uniq) ALL_CLUSTER_CIDRS=$(join_by , $(echo "${ALL_CLUSTER_CIDRS}")) ALL_CLUSTER_NETTAGS=$(gcloud compute instances list --project $PROJECT_1 --format='value(tags.items.[0])' | sort | uniq) ALL_CLUSTER_NETTAGS=$(join_by , $(echo "${ALL_CLUSTER_NETTAGS}"))Cluster specifici
Il comando seguente consente la comunicazione tra
$CLUSTER_1e$CLUSTER_2e non espone altri cluster nel tuo progetto.function join_by { local IFS="$1"; shift; echo "$*"; } ALL_CLUSTER_CIDRS=$(for P in $PROJECT_1 $PROJECT_2; do gcloud --project $P container clusters list --filter="name:($CLUSTER_1,$CLUSTER_2)" --format='value(clusterIpv4Cidr)'; done | sort | uniq) ALL_CLUSTER_CIDRS=$(join_by , $(echo "${ALL_CLUSTER_CIDRS}")) ALL_CLUSTER_NETTAGS=$(for P in $PROJECT_1 $PROJECT_2; do gcloud --project $P compute instances list --filter="name:($CLUSTER_1,$CLUSTER_2)" --format='value(tags.items.[0])' ; done | sort | uniq) ALL_CLUSTER_NETTAGS=$(join_by , $(echo "${ALL_CLUSTER_NETTAGS}"))Crea la regola firewall.
GKE
gcloud compute firewall-rules create istio-multicluster-pods \ --allow=tcp,udp,icmp,esp,ah,sctp \ --direction=INGRESS \ --priority=900 \ --source-ranges="${ALL_CLUSTER_CIDRS}" \ --target-tags="${ALL_CLUSTER_NETTAGS}" --quiet \ --network=YOUR_NETWORKAutopilot
TAGS="" for CLUSTER in ${CLUSTER_1} ${CLUSTER_2} do TAGS+=$(gcloud compute firewall-rules list --filter="Name:$CLUSTER*" --format="value(targetTags)" | uniq) && TAGS+="," done TAGS=${TAGS::-1} echo "Network tags for pod ranges are $TAGS" gcloud compute firewall-rules create asm-multicluster-pods \ --allow=tcp,udp,icmp,esp,ah,sctp \ --network=gke-cluster-vpc \ --direction=INGRESS \ --priority=900 --network=VPC_NAME \ --source-ranges="${ALL_CLUSTER_CIDRS}" \ --target-tags=$TAGS
Configura il rilevamento degli endpoint
Abilita il rilevamento degli endpoint tra cluster pubblici o privati con l'API dichiarativa
L'abilitazione di Cloud Service Mesh gestito con l'API Fleet attiverà il rilevamento degli endpoint per questo cluster. Se hai eseguito il provisioning di Cloud Service Mesh gestito con uno strumento diverso, puoi attivare manualmente il rilevamento degli endpoint nei cluster pubblici o privati di un parco risorse applicando la configurazione "multicluster_mode":"connected" in ConfigMap asm-options. Per i cluster con questa configurazione abilitata nello stesso parco risorse, il Service Discovery tra cluster verrà abilitato automaticamente tra loro.
Questo è l'unico modo per configurare il rilevamento degli endpoint multi-cluster se hai l'implementazione del control plane gestito (TD) e il modo consigliato per configurarlo se hai l'implementazione gestita (Istiod).
Prima di procedere, devi aver creato una regola firewall. Senza questa regola firewall, il bilanciamento del carico del traffico verso altri cluster connected nel parco risorse potrebbe non riuscire (consulta Risoluzione dei problemi multi-cluster).
Abilita
Se la configmap asm-options esiste già nel tuo cluster, attiva il rilevamento degli endpoint per il cluster:
kubectl patch configmap/asm-options -n istio-system --type merge -p '{"data":{"multicluster_mode":"connected"}}'
Se il ConfigMap asm-options non esiste ancora nel tuo cluster, crealo con i dati associati e attiva il rilevamento degli endpoint per il cluster:
kubectl --context ${CTX_1} create configmap asm-options -n istio-system --from-file <(echo '{"data":{"multicluster_mode":"connected"}}')
Disattiva
Disabilita il rilevamento degli endpoint per un cluster:
kubectl patch configmap/asm-options -n istio-system --type merge -p '{"data":{"multicluster_mode":"manual"}}'
La gestione automatica conserva "multicluster_mode":"manual", anche se crei ConfigMap asm-options con "multicluster_mode":"manual" prima di abilitare la gestione automatica su un nuovo cluster.
Se annulli la registrazione di un cluster dal parco risorse senza disattivare il rilevamento degli endpoint, i secret potrebbero rimanere nel cluster. Devi eliminare manualmente i secret rimanenti.
Esegui questo comando per trovare i secret che richiedono la pulizia:
kubectl get secrets -n istio-system -l istio.io/owned-by=mesh.googleapis.com,istio/multiCluster=trueElimina ogni secret:
kubectl delete secret SECRET_NAMERipeti questo passaggio per ogni secret rimanente.
Verifica la connettività multi-cluster
Questa sezione spiega come eseguire il deployment dei servizi HelloWorld e Sleep di esempio nell'ambiente multi-cluster per verificare che il bilanciamento del carico tra cluster funzioni.
Imposta la variabile per la directory degli esempi
Vai alla posizione in cui è stato scaricato
asmclied esegui il seguente comando per impostareASM_VERSIONexport ASM_VERSION="$(./asmcli --version)"Imposta una cartella di lavoro per gli esempi che utilizzi per verificare che il bilanciamento del carico tra cluster funzioni. Gli esempi si trovano in una sottodirectory della directory
--output_dirspecificata nel comandoasmcli install. Nel comando seguente, modificaOUTPUT_DIRnella directory specificata in--output_dir.export SAMPLES_DIR=OUTPUT_DIR/istio-${ASM_VERSION%+*}
Abilita l'iniezione sidecar
Crea lo spazio dei nomi di esempio in ogni cluster.
for CTX in ${CTX_1} ${CTX_2} do kubectl create --context=${CTX} namespace sample doneAbilita lo spazio dei nomi per l'inserimento. I passaggi dipendono dall'implementazione del control plane.
Gestito (TD)
- Applica l'etichetta di inserimento predefinita allo spazio dei nomi:
for CTX in ${CTX_1} ${CTX_2} do kubectl label --context=${CTX} namespace sample \ istio.io/rev- istio-injection=enabled --overwrite doneGestito (Istiod)
Consigliato: esegui questo comando per applicare l'etichetta di inserimento predefinita allo spazio dei nomi:
for CTX in ${CTX_1} ${CTX_2} do kubectl label --context=${CTX} namespace sample \ istio.io/rev- istio-injection=enabled --overwrite doneSe sei un utente esistente con il control plane Istiod gestito: ti consigliamo di utilizzare l'inserimento predefinito, ma è supportato anche l'inserimento basato sulla revisione. Segui queste istruzioni:
Esegui questo comando per individuare i canali di rilascio disponibili:
kubectl -n istio-system get controlplanerevisionL'output è simile al seguente:
NAME AGE asm-managed-rapid 6d7hNell'output, il valore nella colonna
NAMEè l'etichetta della revisione che corrisponde al canale di rilascio disponibile per la versione di Cloud Service Mesh.Applica l'etichetta di revisione allo spazio dei nomi:
for CTX in ${CTX_1} ${CTX_2} do kubectl label --context=${CTX} namespace sample \ istio-injection- istio.io/rev=REVISION_LABEL --overwrite done
Installa il servizio HelloWorld
Crea il servizio HelloWorld in entrambi i cluster:
kubectl create --context=${CTX_1} \ -f ${SAMPLES_DIR}/samples/helloworld/helloworld.yaml \ -l service=helloworld -n samplekubectl create --context=${CTX_2} \ -f ${SAMPLES_DIR}/samples/helloworld/helloworld.yaml \ -l service=helloworld -n sample
Esegui il deployment di HelloWorld v1 e v2 in ogni cluster
Esegui il deployment di
HelloWorld v1suCLUSTER_1e div2suCLUSTER_2. Questa operazione ti aiuterà in un secondo momento a verificare il bilanciamento del carico tra cluster:kubectl create --context=${CTX_1} \ -f ${SAMPLES_DIR}/samples/helloworld/helloworld.yaml \ -l version=v1 -n samplekubectl create --context=${CTX_2} \ -f ${SAMPLES_DIR}/samples/helloworld/helloworld.yaml \ -l version=v2 -n sampleVerifica che
HelloWorld v1ev2siano in esecuzione utilizzando i comandi seguenti. Verifica che l'output sia simile a quello mostrato:kubectl get pod --context=${CTX_1} -n sampleNAME READY STATUS RESTARTS AGE helloworld-v1-86f77cd7bd-cpxhv 2/2 Running 0 40s
kubectl get pod --context=${CTX_2} -n sampleNAME READY STATUS RESTARTS AGE helloworld-v2-758dd55874-6x4t8 2/2 Running 0 40s
Esegui il deployment del servizio Sleep
Esegui il deployment del servizio
Sleepin entrambi i cluster. Questo pod genera traffico di rete artificiale a scopo dimostrativo:for CTX in ${CTX_1} ${CTX_2} do kubectl apply --context=${CTX} \ -f ${SAMPLES_DIR}/samples/sleep/sleep.yaml -n sample doneAttendi l'avvio del servizio
Sleepin ogni cluster. Verifica che l'output sia simile a quello mostrato:kubectl get pod --context=${CTX_1} -n sample -l app=sleepNAME READY STATUS RESTARTS AGE sleep-754684654f-n6bzf 2/2 Running 0 5s
kubectl get pod --context=${CTX_2} -n sample -l app=sleepNAME READY STATUS RESTARTS AGE sleep-754684654f-dzl9j 2/2 Running 0 5s
Verifica il bilanciamento del carico tra cluster
Chiama il servizio HelloWorld più volte e controlla l'output per verificare la presenza di risposte alternate dalle versioni 1 e 2:
Chiama il servizio
HelloWorld:kubectl exec --context="${CTX_1}" -n sample -c sleep \ "$(kubectl get pod --context="${CTX_1}" -n sample -l \ app=sleep -o jsonpath='{.items[0].metadata.name}')" \ -- /bin/sh -c 'for i in $(seq 1 20); do curl -sS helloworld.sample:5000/hello; done'L'output è simile a quello mostrato:
Hello version: v2, instance: helloworld-v2-758dd55874-6x4t8 Hello version: v1, instance: helloworld-v1-86f77cd7bd-cpxhv ...
Chiama di nuovo il servizio
HelloWorld:kubectl exec --context="${CTX_2}" -n sample -c sleep \ "$(kubectl get pod --context="${CTX_2}" -n sample -l \ app=sleep -o jsonpath='{.items[0].metadata.name}')" \ -- /bin/sh -c 'for i in $(seq 1 20); do curl -sS helloworld.sample:5000/hello; done'L'output è simile a quello mostrato:
Hello version: v2, instance: helloworld-v2-758dd55874-6x4t8 Hello version: v1, instance: helloworld-v1-86f77cd7bd-cpxhv ...
Congratulazioni, hai verificato il tuo Cloud Service Mesh multi-cluster con bilanciamento del carico.
Mantenimento del traffico all'interno del cluster
In alcuni casi, il comportamento predefinito del bilanciamento del carico tra cluster non è auspicabile. Per mantenere il traffico "locale al cluster" (ovvero il traffico inviato da cluster-a raggiungerà solo le destinazioni in cluster-a), contrassegna i nomi host o i caratteri jolly come clusterLocal utilizzando MeshConfig.serviceSettings.
Ad esempio, puoi applicare il traffico locale al cluster per un singolo servizio, per tutti i servizi in uno spazio dei nomi specifico o a livello globale per tutti i servizi nel mesh, come segue:
per servizio
serviceSettings:
- settings:
clusterLocal: true
hosts:
- "mysvc.myns.svc.cluster.local"
per-namespace
serviceSettings:
- settings:
clusterLocal: true
hosts:
- "*.myns.svc.cluster.local"
globale
serviceSettings:
- settings:
clusterLocal: true
hosts:
- "*"
Puoi anche perfezionare l'accesso ai servizi impostando una regola globale cluster-local e aggiungendo eccezioni esplicite, che possono essere specifiche o con caratteri jolly. Nell'esempio seguente, tutti i servizi nel cluster verranno mantenuti locali nel cluster, ad eccezione di qualsiasi servizio nello spazio dei nomi myns:
serviceSettings:
- settings:
clusterLocal: true
hosts:
- "*"
- settings:
clusterLocal: false
hosts:
- "*.myns.svc.cluster.local"
Abilita il servizio Local Cluster
Controlla la mappa di configurazione MeshConfig nel cluster
kubectl get configmap -n istio-systemDovresti vedere una mappa di configurazione con uno dei nomi
istio-asm-managed,istio-asm-managed-rapidoistio-asm-managed-stable.Se hai eseguito la migrazione dall'implementazione
ISTIODall'implementazioneTRAFFIC_DIRECTOR, potresti visualizzare più di un ConfigMap. In questo caso, puoi determinare il canale eseguendo questo comando:kubectl get controlplanerevision -n istio-systemIl canale della revisione del control plane riconciliata è quello che devi scegliere.
Aggiorna la mappa di configurazione
cat <<EOF > config.yaml apiVersion: v1 kind: ConfigMap metadata: name: CONFIGMAP_NAME namespace: istio-system data: mesh: |- serviceSettings: - settings: clusterLocal: true hosts: - "*" EOFSostituisci
CONFIGMAP_NAMEcon il nome di ConfigMap trovato nel passaggio 1 e aggiorna ConfigMap.kubectl apply --context=${CTX_1} -f config.yamlVerifica che la funzionalità Cluster locale funzioni come previsto utilizzando i comandi seguenti. L'output per la chiamata di
HelloWorldconCTX_1è simile al seguente:kubectl exec --context="${CTX_1}" -n sample -c sleep \ "$(kubectl get pod --context="${CTX_1}" -n sample -l \ app=sleep -o jsonpath='{.items[0].metadata.name}')" \ -- /bin/sh -c 'for i in $(seq 1 20); do curl -sS helloworld.sample:5000/hello; done'Nell'output dovresti vedere Only v1 is response:
Hello version: v1, instance: helloworld-v2-758dd55874-6x4t8 Hello version: v1, instance: helloworld-v1-86f77cd7bd-cpxhv ...Se chiami
HelloWorldconCTX_2:kubectl exec --context="${CTX_2}" -n sample -c sleep \ "$(kubectl get pod --context="${CTX_2}" -n sample -l \ app=sleep -o jsonpath='{.items[0].metadata.name}')" \ -- /bin/sh -c 'for i in $(seq 1 20); do curl -sS helloworld.sample:5000/hello; done'Nell'output dovresti vedere risposte alternate dalle versioni 1 e 2.
Hello version: v2, instance: helloworld-v2-758dd55874-6x4t8 Hello version: v1, instance: helloworld-v1-86f77cd7bd-cpxhv ...
Esegui la pulizia del servizio HelloWorld
Al termine della verifica del bilanciamento del carico, rimuovi i servizi HelloWorld e Sleep dal cluster.
kubectl delete ns sample --context ${CTX_1}
kubectl delete ns sample --context ${CTX_2}Configurazione del bilanciamento del carico per le località
Cloud Service Mesh ti consente di controllare la distribuzione del traffico tra diverse regioni e zone utilizzando i comportamenti di routing principali:
- SPRAY_TO_WORLD (predefinito): il traffico viene distribuito utilizzando il metodo round robin tra tutti gli endpoint integri a livello globale, indipendentemente dalla posizione del client.
- WATERFALL_BY_ZONE: il traffico viene instradato alla zona più vicina in stato di integrità. Se la zona locale non è integra, il traffico viene indirizzato alla zona integra più vicina.
Questa guida spiega come configurare questi comportamenti utilizzando le risorse Istio DestinationRule e MeshConfig.
Attiva il routing a cascata
Per attivare WATERFALL_BY_ZONE, gli utenti devono configurare DestinationRule.TrafficPolicy.outlierDetection E uno dei seguenti elementi in DestinationRule (o a livello globale in MeshConfig):
localityLbSetting.enabledcometruelocalityLbSetting.failover.fromlocalityLbSetting.failover.to
Attivazione di Waterfall tramite DestinationRule
Di seguito viene descritta una configurazione che attiva correttamente il routing a cascata per un servizio specifico utilizzando un DestinationRule:
apiVersion: networking.istio.io/v1beta1
kind: DestinationRule
metadata:
name: backend-waterfall-rule
spec:
host: my-backend.default.svc.cluster.local
trafficPolicy:
outlierDetection: {}
loadBalancer:
localityLbSetting:
enabled: true # or failover: []
Attivazione di Waterfall utilizzando MeshConfig + DestinationRule
In alternativa, puoi attivare il bilanciamento del carico di località a livello globale per l'intero mesh nel cluster utilizzando MeshConfig (ad esempio, in ConfigMap istio-asm-managed). Quando localityLbSetting viene applicato all'intero mesh, i singoli DestinationRule devono solo avere un blocco outlierDetection vuoto per attivare il routing di Waterfall.
I seguenti file YAML forniscono un MeshConfig e un DestinationRule di esempio per questa configurazione:
MeshConfig (globale):
apiVersion: v1
kind: ConfigMap
metadata:
name: istio-asm-managed
namespace: istio-system
data:
mesh: |-
localityLbSetting:
enabled: true # or failover: []
DestinationRule (specifico per il servizio):
apiVersion: networking.istio.io/v1beta1
kind: DestinationRule
metadata:
name: backend-waterfall-rule
spec:
host: my-backend.default.svc.cluster.local
trafficPolicy:
outlierDetection: {}
Applicazione delle impostazioni di località per versione del workload
Poiché le impostazioni di località specifiche per sottoinsieme e porta non sono supportate in DestinationRule, puoi utilizzare più definizioni di servizi Kubernetes per fornire impostazioni di routing per servizio e ottenere un comportamento di località mista.