Questo deployment mostra come combinare Cloud Service Mesh con Cloud Load Balancing per esporre le applicazioni in un mesh di servizi ai client internet.
Puoi esporre un'applicazione ai client in molti modi, a seconda di dove si trova il client. Questo deployment mostra come esporre un'applicazione ai client combinando Cloud Load Balancing con Cloud Service Mesh per integrare i bilanciatori del carico con un mesh di servizi. Questo deployment è destinato a professionisti avanzati che eseguono Cloud Service Mesh, ma funziona anche per Istio su Google Kubernetes Engine.
Architettura
Il seguente diagramma mostra come utilizzare i gateway in entrata mesh per integrare i bilanciatori del carico con un mesh di servizi:
Nella topologia del diagramma precedente, il livello cloud in entrata, programmato tramite il gateway GKE, genera il traffico dall'esterno del mesh di servizi e lo indirizza al livello mesh in entrata. Il livello mesh Ingress indirizza quindi il traffico ai backend delle applicazioni ospitati dalla rete mesh.
La topologia precedente contiene le seguenti considerazioni:
- In entrata nel cloud: in questa architettura di riferimento, configuri il bilanciatore del carico Google Cloud tramite il gateway GKE per verificare l'integrità dei proxy in entrata mesh sulle porte esposte per il controllo di integrità.
- Ingresso mesh: nell'applicazione mesh, i controlli di integrità vengono eseguiti direttamente sui backend in modo da poter eseguire il bilanciamento del carico e la gestione del traffico in locale.
Il diagramma precedente illustra la crittografia HTTPS dal client al bilanciatore del carico Google Cloud, dal bilanciatore del carico al proxy in entrata del mesh e dal proxy in entrata al proxy sidecar.
Obiettivi
- Eseguire il deployment di un cluster Google Kubernetes Engine (GKE) su Google Cloud.
- Esegui il deployment di un Cloud Service Mesh basato su Istio sul tuo cluster GKE.
- Configura il gateway GKE per terminare il traffico HTTPS pubblico e indirizzarlo alle applicazioni di servizio con hosting mesh.
- Esegui il deployment dell'applicazione Online Boutique sul cluster GKE esponi ai client su internet.
Ottimizzazione dei costi
In questo documento, utilizzi i seguenti componenti fatturabili di Google Cloud:
- Google Kubernetes Engine
- Compute Engine
- Cloud Load Balancing
- Certificate Manager
- Cloud Service Mesh
- Google Cloud Armor
- Cloud Endpoints
Per generare una stima dei costi in base all'utilizzo previsto, utilizza il Calcolatore prezzi.
Una volta completate le attività descritte in questo documento, puoi evitare la fatturazione continua eliminando le risorse che hai creato. Per ulteriori informazioni, consulta la pagina Pulizia.
Prima di iniziare
-
In the Google Cloud console, on the project selector page, select or create a Google Cloud project.
-
Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.
-
Nella console Google Cloud, attiva Cloud Shell.
Esegui tutti i comandi del terminale per questo deployment da Cloud Shell.
Esegui l'upgrade alla versione più recente di Google Cloud CLI:
gcloud components update
Imposta il progetto Google Cloud predefinito:
export PROJECT=PROJECT export PROJECT_NUMBER=$(gcloud projects describe ${PROJECT} --format="value(projectNumber)") gcloud config set project ${PROJECT}
Sostituisci
PROJECT
con l'ID progetto che vuoi utilizzare per questo deployment.Crea una directory di lavoro:
mkdir -p ${HOME}/edge-to-mesh cd ${HOME}/edge-to-mesh export WORKDIR=`pwd`
Al termine del deployment, puoi eliminare la directory di lavoro.
crea cluster GKE
Le funzionalità descritte in questo deployment richiedono un cluster GKE versione 1.16 o successiva.
In Cloud Shell, crea un nuovo file
kubeconfig
. Questo passaggio garantisce di non creare un conflitto con il filekubeconfig
esistente (predefinito).touch edge2mesh_kubeconfig export KUBECONFIG=${WORKDIR}/edge2mesh_kubeconfig
Definisci le variabili di ambiente per il cluster GKE:
export CLUSTER_NAME=edge-to-mesh export CLUSTER_LOCATION=us-central1
Abilita l'API Google Kubernetes Engine:
gcloud services enable container.googleapis.com
Crea un cluster GKE Autopilot:
gcloud container --project ${PROJECT} clusters create-auto ${CLUSTER_NAME} --region ${CLUSTER_LOCATION} --release-channel rapid
Assicurati che il cluster sia in esecuzione:
gcloud container clusters list
L'output è simile al seguente:
NAME LOCATION MASTER_VERSION MASTER_IP MACHINE_TYPE NODE_VERSION NUM_NODES STATUS edge-to-mesh us-central1 1.27.3-gke.1700 34.122.84.52 e2-medium 1.27.3-gke.1700 3 RUNNING
Installa un mesh di servizi
In questa sezione configurerai il Cloud Service Mesh gestito con l'API del parco risorse.
In Cloud Shell, abilita le API richieste:
gcloud services enable mesh.googleapis.com
Abilita Cloud Service Mesh nel parco risorse:
gcloud container fleet mesh enable
Registra il cluster nel parco risorse:
gcloud container fleet memberships register ${CLUSTER_NAME} \ --gke-cluster ${CLUSTER_LOCATION}/${CLUSTER_NAME}
Applica l'etichetta
mesh_id
al clusteredge-to-mesh
:gcloud container clusters update ${CLUSTER_NAME} --project ${PROJECT} --region ${CLUSTER_LOCATION} --update-labels mesh_id=proj-${PROJECT_NUMBER}
Abilita la gestione automatica del piano di controllo e il piano dati gestito:
gcloud container fleet mesh update \ --management automatic \ --memberships ${CLUSTER_NAME}
Dopo qualche minuto, verifica che lo stato del piano di controllo sia
ACTIVE
:gcloud container fleet mesh describe
L'output è simile al seguente:
... membershipSpecs: projects/892585880385/locations/us-central1/memberships/edge-to-mesh: mesh: management: MANAGEMENT_AUTOMATIC membershipStates: projects/892585880385/locations/us-central1/memberships/edge-to-mesh: servicemesh: controlPlaneManagement: details: - code: REVISION_READY details: 'Ready: asm-managed-rapid' state: ACTIVE dataPlaneManagement: details: - code: OK details: Service is running. state: ACTIVE state: code: OK description: 'Revision(s) ready for use: asm-managed-rapid.' updateTime: '2023-08-04T02:54:39.495937877Z' name: projects/e2m-doc-01/locations/global/features/servicemesh resourceState: state: ACTIVE ...
Esegui il deployment del gateway GKE
Nei passaggi seguenti, eseguirai il deployment del bilanciatore del carico delle applicazioni esterno tramite il controller gateway GKE. La risorsa gateway GKE automatizza il provisioning del bilanciatore del carico e il controllo di integrità del backend. Inoltre, puoi utilizzare Gestione certificati per eseguire il provisioning e gestire un certificato TLS ed Endpoints per eseguire automaticamente il provisioning di un nome DNS pubblico per l'applicazione.
Installa un gateway in entrata della rete mesh di servizi
Come best practice per la sicurezza, ti consigliamo di eseguire il deployment del gateway in entrata in uno spazio dei nomi diverso dal piano di controllo.
In Cloud Shell, crea uno spazio dei nomi
asm-ingress
dedicato:kubectl create namespace asm-ingress
Aggiungi un'etichetta dello spazio dei nomi allo spazio dei nomi
asm-ingress
:kubectl label namespace asm-ingress istio-injection=enabled
L'output è simile al seguente:
namespace/asm-ingress labeled
L'etichettatura dello spazio dei nomi
asm-ingress
conistio-injection=enabled
indica a Cloud Service Mesh di inserire automaticamente i proxy sidecar Envoy quando viene eseguito il deployment di un'applicazione.Crea un certificato autofirmato utilizzato dal gateway in entrata per terminare le connessioni TLS tra il bilanciatore del carico Google Cloud (da configurare in un secondo momento tramite il controller gateway GKE) e il gateway in entrata, quindi archivia il certificato autofirmato come secret di Kubernetes:
openssl req -new -newkey rsa:4096 -days 365 -nodes -x509 \ -subj "/CN=frontend.endpoints.${PROJECT}.cloud.goog/O=Edge2Mesh Inc" \ -keyout frontend.endpoints.${PROJECT}.cloud.goog.key \ -out frontend.endpoints.${PROJECT}.cloud.goog.crt kubectl -n asm-ingress create secret tls edge2mesh-credential \ --key=frontend.endpoints.${PROJECT}.cloud.goog.key \ --cert=frontend.endpoints.${PROJECT}.cloud.goog.crt
Per ulteriori dettagli sui requisiti del certificato del gateway in entrata, consulta la guida alle considerazioni sul protocollo di backend sicuro.
Esegui questi comandi per creare il file YAML della risorsa gateway in entrata:
mkdir -p ${WORKDIR}/asm-ig/base cat <<EOF > ${WORKDIR}/asm-ig/base/kustomization.yaml resources: - github.com/GoogleCloudPlatform/anthos-service-mesh-samples/docs/ingress-gateway-asm-manifests/base EOF mkdir ${WORKDIR}/asm-ig/variant cat <<EOF > ${WORKDIR}/asm-ig/variant/role.yaml apiVersion: rbac.authorization.k8s.io/v1 kind: Role metadata: name: asm-ingressgateway namespace: asm-ingress rules: - apiGroups: [""] resources: ["secrets"] verbs: ["get", "watch", "list"] EOF cat <<EOF > ${WORKDIR}/asm-ig/variant/rolebinding.yaml apiVersion: rbac.authorization.k8s.io/v1 kind: RoleBinding metadata: name: asm-ingressgateway namespace: asm-ingress roleRef: apiGroup: rbac.authorization.k8s.io kind: Role name: asm-ingressgateway subjects: - kind: ServiceAccount name: asm-ingressgateway EOF cat <<EOF > ${WORKDIR}/asm-ig/variant/service-proto-type.yaml apiVersion: v1 kind: Service metadata: name: asm-ingressgateway spec: ports: - name: status-port port: 15021 protocol: TCP targetPort: 15021 - name: http port: 80 targetPort: 8080 - name: https port: 443 targetPort: 8443 appProtocol: HTTP2 type: ClusterIP EOF cat <<EOF > ${WORKDIR}/asm-ig/variant/gateway.yaml apiVersion: networking.istio.io/v1beta1 kind: Gateway metadata: name: asm-ingressgateway spec: servers: - port: number: 443 name: https protocol: HTTPS hosts: - "*" # IMPORTANT: Must use wildcard here when using SSL, see note below tls: mode: SIMPLE credentialName: edge2mesh-credential EOF cat <<EOF > ${WORKDIR}/asm-ig/variant/kustomization.yaml namespace: asm-ingress resources: - ../base - role.yaml - rolebinding.yaml patches: - path: service-proto-type.yaml target: kind: Service - path: gateway.yaml target: kind: Gateway EOF
Applica i CRD del gateway in entrata:
kubectl apply -k ${WORKDIR}/asm-ig/variant
Assicurati che tutti i deployment siano attivi e in esecuzione:
kubectl wait --for=condition=available --timeout=600s deployment --all -n asm-ingress
L'output è simile al seguente:
deployment.apps/asm-ingressgateway condition met
Applica un controllo di integrità del gateway in entrata della rete mesh di servizi
Quando integri un gateway in entrata del mesh di servizi in un bilanciatore del carico dell'applicazione Google Cloud, quest'ultimo deve essere configurato per eseguire i controlli di integrità sui pod del gateway in entrata. Il CRD HealthCheckPolicy
fornisce un'API per configurare il controllo di integrità.
In Cloud Shell, crea il file
HealthCheckPolicy.yaml
:cat <<EOF >${WORKDIR}/ingress-gateway-healthcheck.yaml apiVersion: networking.gke.io/v1 kind: HealthCheckPolicy metadata: name: ingress-gateway-healthcheck namespace: asm-ingress spec: default: checkIntervalSec: 20 timeoutSec: 5 #healthyThreshold: HEALTHY_THRESHOLD #unhealthyThreshold: UNHEALTHY_THRESHOLD logConfig: enabled: True config: type: HTTP httpHealthCheck: #portSpecification: USE_NAMED_PORT port: 15021 portName: status-port #host: HOST requestPath: /healthz/ready #response: RESPONSE #proxyHeader: PROXY_HEADER #requestPath: /healthz/ready #port: 15021 targetRef: group: "" kind: Service name: asm-ingressgateway EOF
Applica il
HealthCheckPolicy:
kubectl apply -f ${WORKDIR}/ingress-gateway-healthcheck.yaml
Definisci i criteri di sicurezza
Google Cloud Armor fornisce difesa dagli attacchi DDoS e criteri di sicurezza personalizzabili che puoi collegare a un bilanciatore del carico tramite le risorse Ingress. Nei seguenti passaggi, creerai un criterio di sicurezza che utilizza regole preconfigurate per bloccare gli attacchi di cross-site scripting (XSS). Questa regola consente di bloccare il traffico che corrisponde alle firme di attacco note, ma consente tutto il resto. Il tuo ambiente potrebbe utilizzare regole diverse a seconda del carico di lavoro.
In Cloud Shell, crea un criterio di sicurezza denominato
edge-fw-policy
:gcloud compute security-policies create edge-fw-policy \ --description "Block XSS attacks"
Crea una regola del criterio di sicurezza che utilizzi i filtri XSS preconfigurati:
gcloud compute security-policies rules create 1000 \ --security-policy edge-fw-policy \ --expression "evaluatePreconfiguredExpr('xss-stable')" \ --action "deny-403" \ --description "XSS attack filtering"
Crea il file
GCPBackendPolicy.yaml
da allegare al servizio gateway in entrata:cat <<EOF > ${WORKDIR}/cloud-armor-backendpolicy.yaml apiVersion: networking.gke.io/v1 kind: GCPBackendPolicy metadata: name: cloud-armor-backendpolicy namespace: asm-ingress spec: default: securityPolicy: edge-fw-policy targetRef: group: "" kind: Service name: asm-ingressgateway EOF
Applica il file
GCPBackendPolicy.yaml
:kubectl apply -f ${WORKDIR}/cloud-armor-backendpolicy.yaml
Configura indirizzi IP e DNS
In Cloud Shell, crea un indirizzo IP statico globale per il bilanciatore del carico Google Cloud:
gcloud compute addresses create e2m-gclb-ip --global
Questo indirizzo IP statico viene utilizzato dalla risorsa gateway GKE e consente all'indirizzo IP di rimanere invariato, anche in caso di modifica del bilanciatore del carico esterno.
Ottieni l'indirizzo IP statico:
export GCLB_IP=$(gcloud compute addresses describe e2m-gclb-ip --global --format "value(address)") echo ${GCLB_IP}
Per creare una mappatura stabile e facile da usare all'indirizzo IP statico del bilanciatore del carico delle applicazioni, devi avere un record DNS pubblico. Puoi utilizzare qualsiasi provider DNS e qualsiasi automazione che desideri. Questo deployment utilizza endpoint anziché creare una zona DNS gestita. Endpoints fornisce un record DNS gestito da Google gratuito per un indirizzo IP pubblico.
Esegui questo comando per creare il file delle specifiche YAML denominato
dns-spec.yaml
:cat <<EOF > ${WORKDIR}/dns-spec.yaml swagger: "2.0" info: description: "Cloud Endpoints DNS" title: "Cloud Endpoints DNS" version: "1.0.0" paths: {} host: "frontend.endpoints.${PROJECT}.cloud.goog" x-google-endpoints: - name: "frontend.endpoints.${PROJECT}.cloud.goog" target: "${GCLB_IP}" EOF
La specifica YAML definisce il record DNS pubblico sotto forma di
frontend.endpoints.${PROJECT}.cloud.goog
, dove${PROJECT}
è l'identificatore univoco del progetto.Esegui il deployment del file
dns-spec.yaml
nel tuo progetto Google Cloud:gcloud endpoints services deploy ${WORKDIR}/dns-spec.yaml
L'output è simile al seguente:
project [e2m-doc-01]... Operation "operations/acat.p2-892585880385-fb4a01ad-821d-4e22-bfa1-a0df6e0bf589" finished successfully. Service Configuration [2023-08-04r0] uploaded for service [frontend.endpoints.e2m-doc-01.cloud.goog]
Ora che l'indirizzo IP e il DNS sono configurati, puoi generare un certificato pubblico per proteggere il frontend. Per l'integrazione con GKE Gateway, puoi utilizzare i certificati TLS di Gestore certificati.
Esegui il provisioning di un certificato TLS
In questa sezione, creerai un certificato TLS utilizzando Gestore certificati e lo assocerai a una mappa di certificati tramite una voce di mappa di certificati. Il bilanciatore del carico delle applicazioni, configurato tramite il gateway GKE, utilizza il certificato per fornire comunicazioni sicure tra il client e Google Cloud. Dopo la creazione, la risorsa gateway GKE fa riferimento alla voce della mappa dei certificati.
In Cloud Shell, abilita l'API Certificate Manager:
gcloud services enable certificatemanager.googleapis.com --project=${PROJECT}
Crea il certificato TLS:
gcloud --project=${PROJECT} certificate-manager certificates create edge2mesh-cert \ --domains="frontend.endpoints.${PROJECT}.cloud.goog"
Crea la mappa di certificati:
gcloud --project=${PROJECT} certificate-manager maps create edge2mesh-cert-map
Collega il certificato alla mappa di certificati con una voce di mappa di certificati:
gcloud --project=${PROJECT} certificate-manager maps entries create edge2mesh-cert-map-entry \ --map="edge2mesh-cert-map" \ --certificates="edge2mesh-cert" \ --hostname="frontend.endpoints.${PROJECT}.cloud.goog"
Esegui il deployment del gateway GKE e di HTTPRoute
risorse
In questa sezione configurerai la risorsa gateway GKE che esegue il provisioning del bilanciatore del carico dell'applicazione Google Cloud utilizzando l'gke-l7-global-external-managed
gatewayClass
.
Inoltre, configurerai le risorse di HTTPRoute
che instradano le richieste all'applicazione ed eseguono reindirizzamenti da HTTP a HTTP(S).
In Cloud Shell, esegui questo comando per creare il manifest
Gateway
comegke-gateway.yaml
:cat <<EOF > ${WORKDIR}/gke-gateway.yaml kind: Gateway apiVersion: gateway.networking.k8s.io/v1beta1 metadata: name: external-http namespace: asm-ingress annotations: networking.gke.io/certmap: edge2mesh-cert-map spec: gatewayClassName: gke-l7-global-external-managed # gke-l7-gxlb listeners: - name: http # list the port only so we can redirect any incoming http requests to https protocol: HTTP port: 80 - name: https protocol: HTTPS port: 443 addresses: - type: NamedAddress value: e2m-gclb-ip # reference the static IP created earlier EOF
Applica il manifest
Gateway
per creare unGateway
denominatoexternal-http
:kubectl apply -f ${WORKDIR}/gke-gateway.yaml
Crea il file
HTTPRoute.yaml
predefinito:cat << EOF > ${WORKDIR}/default-httproute.yaml apiVersion: gateway.networking.k8s.io/v1beta1 kind: HTTPRoute metadata: name: default-httproute namespace: asm-ingress spec: parentRefs: - name: external-http namespace: asm-ingress sectionName: https rules: - matches: - path: value: / backendRefs: - name: asm-ingressgateway port: 443 EOF
Applica il valore predefinito
HTTPRoute
:kubectl apply -f ${WORKDIR}/default-httproute.yaml
Crea un file
HTTPRoute.yaml
aggiuntivo per eseguire i reindirizzamenti da HTTP a HTTP(S):cat << EOF > ${WORKDIR}/default-httproute-redirect.yaml kind: HTTPRoute apiVersion: gateway.networking.k8s.io/v1beta1 metadata: name: http-to-https-redirect-httproute namespace: asm-ingress spec: parentRefs: - name: external-http namespace: asm-ingress sectionName: http rules: - filters: - type: RequestRedirect requestRedirect: scheme: https statusCode: 301 EOF
Applica il reindirizzamento
HTTPRoute
:kubectl apply -f ${WORKDIR}/default-httproute-redirect.yaml
La riconciliazione richiede tempo. Utilizza il seguente comando fino al giorno
programmed=true
:kubectl get gateway external-http -n asm-ingress -w
Installa l'app di esempio Online Boutique
In Cloud Shell, crea uno spazio dei nomi
onlineboutique
dedicato:kubectl create namespace onlineboutique
Aggiungi un'etichetta allo spazio dei nomi
onlineboutique
:kubectl label namespace onlineboutique istio-injection=enabled
L'etichettatura dello spazio dei nomi
onlineboutique
conistio-injection=enabled
indica a Cloud Service Mesh di inserire automaticamente i proxy sidecar Envoy quando viene eseguito il deployment di un'applicazione.Scarica i file YAML di Kubernetes per l'app di esempio Online Boutique:
curl -LO \ https://raw.githubusercontent.com/GoogleCloudPlatform/microservices-demo/main/release/kubernetes-manifests.yaml
Esegui il deployment dell'app Online Boutique:
kubectl apply -f kubernetes-manifests.yaml -n onlineboutique
L'output è simile al seguente (inclusi gli avvisi sull'impostazione di richieste e limiti predefiniti per le risorse di GKE Autopilot):
Warning: autopilot-default-resources-mutator:Autopilot updated Deployment onlineboutique/emailservice: adjusted resources to meet requirements for containers [server] (see http://g.co/gke/autopilot-resources) deployment.apps/emailservice created service/emailservice created Warning: autopilot-default-resources-mutator:Autopilot updated Deployment onlineboutique/checkoutservice: adjusted resources to meet requirements for containers [server] (see http://g.co/gke/autopilot-resources) deployment.apps/checkoutservice created service/checkoutservice created Warning: autopilot-default-resources-mutator:Autopilot updated Deployment onlineboutique/recommendationservice: adjusted resources to meet requirements for containers [server] (see http://g.co/gke/autopilot-resources) deployment.apps/recommendationservice created service/recommendationservice created ...
Assicurati che tutti i deployment siano attivi e in esecuzione:
kubectl get pods -n onlineboutique
L'output è simile al seguente:
NAME READY STATUS RESTARTS AGE adservice-64d8dbcf59-krrj9 2/2 Running 0 2m59s cartservice-6b77b89c9b-9qptn 2/2 Running 0 2m59s checkoutservice-7668b7fc99-5bnd9 2/2 Running 0 2m58s ...
Attendi alcuni minuti affinché il cluster GKE Autopilot esegua il provisioning dell'infrastruttura di calcolo necessaria per supportare l'applicazione.
Esegui questo comando per creare il manifest
VirtualService
comefrontend-virtualservice.yaml
:cat <<EOF > frontend-virtualservice.yaml apiVersion: networking.istio.io/v1beta1 kind: VirtualService metadata: name: frontend-ingress namespace: onlineboutique spec: hosts: - "frontend.endpoints.${PROJECT}.cloud.goog" gateways: - asm-ingress/asm-ingressgateway http: - route: - destination: host: frontend port: number: 80 EOF
VirtualService
viene creato nello spazio dei nomi dell'applicazione (onlineboutique
). In genere, il proprietario dell'applicazione decide e configura come e quale traffico viene instradato all'applicazionefrontend
, in modo che il proprietario dell'app esegua il deployment diVirtualService
.Esegui il deployment di
frontend-virtualservice.yaml
nel tuo cluster:kubectl apply -f frontend-virtualservice.yaml
Accedi al seguente link:
echo "https://frontend.endpoints.${PROJECT}.cloud.goog"
Viene visualizzato il frontend della tua boutique online.
Per visualizzare i dettagli del certificato, fai clic su
Visualizza informazioni sul sito nella barra degli indirizzi del browser, quindi su Certificato (valido).Nel visualizzatore certificati vengono visualizzati i dettagli del certificato gestito, tra cui la data di scadenza e l'autore del certificato.
Ora hai a disposizione un bilanciatore del carico HTTPS globale che funge da frontend per la tua applicazione con hosting mesh di servizi.
Esegui la pulizia
Al termine del deployment, puoi eseguire la pulizia delle risorse che hai creato su Google Cloud in modo che non ti vengano addebitati costi in futuro. Puoi eliminare completamente il progetto o eliminare le risorse del cluster e quindi eliminare il cluster.
Elimina il progetto
- Nella console Google Cloud, vai alla pagina Gestisci risorse.
- Nell'elenco dei progetti, seleziona il progetto che vuoi eliminare, quindi fai clic su Elimina.
- Nella finestra di dialogo, digita l'ID del progetto e fai clic su Chiudi per eliminare il progetto.
Elimina le singole risorse
Se vuoi conservare il progetto Google Cloud utilizzato in questo deployment, elimina le singole risorse:
In Cloud Shell, elimina le risorse
HTTPRoute
:kubectl delete -f ${WORKDIR}/default-httproute-redirect.yaml kubectl delete -f ${WORKDIR}/default-httproute.yaml
Elimina la risorsa gateway GKE:
kubectl delete -f ${WORKDIR}/gke-gateway.yaml
Elimina le risorse del certificato TLS (inclusa la voce della mappa di certificati e la mappa di certificati padre):
gcloud --project=${PROJECT} certificate-manager maps entries delete edge2mesh-cert-map-entry --map="edge2mesh-cert-map" --quiet gcloud --project=${PROJECT} certificate-manager maps delete edge2mesh-cert-map --quiet gcloud --project=${PROJECT} certificate-manager certificates delete edge2mesh-cert --quiet
Elimina la voce DNS Endpoints:
gcloud endpoints services delete "frontend.endpoints.${PROJECT}.cloud.goog"
L'output è simile al seguente:
Are you sure? This will set the service configuration to be deleted, along with all of the associated consumer information. Note: This does not immediately delete the service configuration or data and can be undone using the undelete command for 30 days. Only after 30 days will the service be purged from the system.
Quando ti viene chiesto di continuare, digita Y.
L'output è simile al seguente:
Waiting for async operation operations/services.frontend.endpoints.edge2mesh.cloud.goog-5 to complete... Operation finished successfully. The following command can describe the Operation details: gcloud endpoints operations describe operations/services.frontend.endpoints.edge2mesh.cloud.goog-5
Elimina l'indirizzo IP statico:
gcloud compute addresses delete ingress-ip --global
L'output è simile al seguente:
The following global addresses will be deleted: - [ingress-ip]
Quando ti viene chiesto di continuare, digita Y.
L'output è simile al seguente:
Deleted [https://www.googleapis.com/compute/v1/projects/edge2mesh/global/addresses/ingress-ip].
Elimina il cluster GKE:
gcloud container clusters delete $CLUSTER_NAME --zone $CLUSTER_LOCATION
L'output è simile al seguente:
The following clusters will be deleted. - [edge-to-mesh] in [us-central1]
Quando ti viene chiesto di continuare, digita Y.
Dopo alcuni minuti, l'output è simile al seguente:
Deleting cluster edge-to-mesh...done. Deleted [https://container.googleapis.com/v1/projects/e2m-doc-01/zones/us-central1/clusters/edge-to-mesh].
Passaggi successivi
- Scopri altre funzionalità offerte da GKE Ingress che puoi utilizzare con il tuo mesh di servizi.
- Scopri di più sui diversi tipi di bilanciamento del carico cloud disponibili per GKE.
- Scopri le caratteristiche e le funzionalità offerte da Cloud Service Mesh.
- Scopri come eseguire il deployment di Ingress in più cluster GKE per il bilanciamento del carico tra più regioni.
- Per altre architetture di riferimento, diagrammi e best practice, esplora il Cloud Architecture Center.