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 della posizione del 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 esperti che eseguono Cloud Service Mesh, ma funziona anche per Istio su Google Kubernetes Engine.
Architettura
Il seguente diagramma mostra come utilizzare i gateway di ingresso mesh per integrare i bilanciatori del carico con unmesh di servizih:
Nella topologia del diagramma precedente, il livello di ingresso cloud, programmato tramite GKE Gateway, recupera il traffico dall'esterno delmesh di servizih e lo indirizza al livello di ingresso del mesh. Il livello di ingresso del mesh indirizza quindi il traffico ai backend delle applicazioni ospitate nel mesh.
La topologia precedente presenta le seguenti considerazioni:
- Ingresso cloud:in questa architettura di riferimento, configuri il bilanciatore del caricoGoogle Cloud tramite GKE Gateway per controllare l'integrità dei proxy di ingresso mesh sulle porte del controllo di integrità esposte.
- Ingresso mesh:nell'applicazione mesh, esegui controlli di integrità sui backend direttamente in modo da poter eseguire il bilanciamento del carico e la gestione del traffico localmente.
Il diagramma precedente illustra la crittografia HTTPS dal client al bilanciatore del carico Google Cloud , dal bilanciatore del carico al proxy di ingresso mesh e dal proxy di ingresso al proxy sidecar.
Obiettivi
- Esegui 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 GKE Gateway per terminare il traffico HTTPS pubblico e indirizzarlo alle applicazioni ospitate nel mesh di servizi.
- Esegui il deployment dell'applicazione Online Boutique sul cluster GKE che esponi ai client su internet.
Ottimizzazione dei costi
In questo documento vengono utilizzati 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.
Al termine delle attività descritte in questo documento, puoi evitare l'addebito di ulteriori costi eliminando le risorse che hai creato. Per ulteriori informazioni, vedi Pulizia.
Prima di iniziare
-
In the Google Cloud console, on the project selector page, select or create a Google Cloud project.
Roles required to select or create a project
- Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
-
Create a project: To create a project, you need the Project Creator
(
roles/resourcemanager.projectCreator), which contains theresourcemanager.projects.createpermission. Learn how to grant roles.
-
Verify that billing is enabled for your Google Cloud project.
-
In the Google Cloud console, activate Cloud Shell.
Esegui tutti i comandi del terminale per questo deployment da Cloud Shell.
Esegui l'upgrade all'ultima versione di Google Cloud CLI:
gcloud components updateImposta il progetto Google Cloud predefinito:
export PROJECT=PROJECT export PROJECT_NUMBER=$(gcloud projects describe ${PROJECT} --format="value(projectNumber)") gcloud config set project ${PROJECT}Sostituisci
PROJECTcon 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.
In Cloud Shell, crea un nuovo file
kubeconfig. Questo passaggio assicura di non creare un conflitto con il filekubeconfigesistente (predefinito).touch edge2mesh_kubeconfig export KUBECONFIG=${WORKDIR}/edge2mesh_kubeconfigDefinisci le variabili di ambiente per il cluster GKE:
export CLUSTER_NAME=edge-to-mesh export CLUSTER_LOCATION=us-central1Attiva l'API Google Kubernetes Engine:
gcloud services enable container.googleapis.comCrea un cluster GKE Autopilot:
gcloud container --project ${PROJECT} clusters create-auto \ ${CLUSTER_NAME} --region ${CLUSTER_LOCATION} --release-channel rapidAssicurati che il cluster sia in esecuzione:
gcloud container clusters listL'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
In Cloud Shell, abilita le API richieste:
gcloud services enable mesh.googleapis.comAttiva Cloud Service Mesh sul parco risorse:
gcloud container fleet mesh enableRegistra il cluster nel parco risorse:
gcloud container fleet memberships register ${CLUSTER_NAME} \ --gke-cluster ${CLUSTER_LOCATION}/${CLUSTER_NAME}Applica l'etichetta
mesh_idal 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 control plane e del data plane gestito:
gcloud container fleet mesh update \ --management automatic \ --memberships ${CLUSTER_NAME}Dopo qualche minuto, verifica che lo stato del control plane sia
ACTIVE:gcloud container fleet mesh describeL'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' implementation: TRAFFIC_DIRECTOR 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 ...In Cloud Shell, crea uno spazio dei nomi
ingress-gatewaydedicato:kubectl create namespace ingress-gatewayAggiungi un'etichetta dello spazio dei nomi allo spazio dei nomi
ingress-gateway:kubectl label namespace ingress-gateway istio-injection=enabledL'output è simile al seguente:
namespace/ingress-gateway labeled
L'etichettatura dello spazio dei nomi
ingress-gatewayconistio-injection=enabledindica 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 GKE Gateway) e il gateway in entrata e archivia il certificato autofirmato come secret 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 ingress-gateway create secret tls edge2mesh-credential \ --key=frontend.endpoints.${PROJECT}.cloud.goog.key \ --cert=frontend.endpoints.${PROJECT}.cloud.goog.crtPer maggiori dettagli sui requisiti del certificato del gateway in entrata, consulta la guida alle considerazioni sul protocollo di backend sicuro.
Esegui i seguenti comandi per creare il file YAML della risorsa del gateway in entrata:
mkdir -p ${WORKDIR}/ingress-gateway/base cat <<EOF > ${WORKDIR}/ingress-gateway/base/kustomization.yaml resources: - github.com/GoogleCloudPlatform/anthos-service-mesh-samples/docs/ingress-gateway-asm-manifests/base EOF mkdir ${WORKDIR}/ingress-gateway/variant cat <<EOF > ${WORKDIR}/ingress-gateway/variant/role.yaml apiVersion: rbac.authorization.k8s.io/v1 kind: Role metadata: name: asm-ingressgateway rules: - apiGroups: [""] resources: ["secrets"] verbs: ["get", "watch", "list"] EOF cat <<EOF > ${WORKDIR}/ingress-gateway/variant/rolebinding.yaml apiVersion: rbac.authorization.k8s.io/v1 kind: RoleBinding metadata: name: asm-ingressgateway roleRef: apiGroup: rbac.authorization.k8s.io kind: Role name: asm-ingressgateway subjects: - kind: ServiceAccount name: asm-ingressgateway EOF cat <<EOF > ${WORKDIR}/ingress-gateway/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}/ingress-gateway/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, as SNI isn't passed from GFE tls: mode: SIMPLE credentialName: edge2mesh-credential EOF cat <<EOF > ${WORKDIR}/ingress-gateway/variant/kustomization.yaml namespace: ingress-gateway resources: - ../base - role.yaml - rolebinding.yaml patches: - path: service-proto-type.yaml target: kind: Service - path: gateway.yaml target: kind: Gateway EOFApplica i CRD del gateway in entrata:
kubectl apply -k ${WORKDIR}/ingress-gateway/variantAssicurati che tutti i deployment siano in esecuzione:
kubectl wait --for=condition=available --timeout=600s deployment --all -n ingress-gatewayL'output è simile al seguente:
deployment.apps/asm-ingressgateway condition met
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: ingress-gateway 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 EOFApplica
HealthCheckPolicy:kubectl apply -f ${WORKDIR}/ingress-gateway-healthcheck.yamlIn Cloud Shell, crea una policy di sicurezza denominata
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.yamlda allegare al servizio gateway ingress:cat <<EOF > ${WORKDIR}/cloud-armor-backendpolicy.yaml apiVersion: networking.gke.io/v1 kind: GCPBackendPolicy metadata: name: cloud-armor-backendpolicy namespace: ingress-gateway spec: default: securityPolicy: edge-fw-policy targetRef: group: "" kind: Service name: asm-ingressgateway EOFApplica il file
GCPBackendPolicy.yaml:kubectl apply -f ${WORKDIR}/cloud-armor-backendpolicy.yamlIn Cloud Shell, crea un indirizzo IP statico globale per il bilanciatore del caricoGoogle Cloud :
gcloud compute addresses create e2m-gclb-ip --globalQuesto indirizzo IP statico viene utilizzato dalla risorsa GKE Gateway e consente all'indirizzo IP di rimanere invariato, anche se il bilanciatore del carico esterno cambia.
Ottieni l'indirizzo IP statico:
export GCLB_IP=$(gcloud compute addresses describe e2m-gclb-ip \ --global --format "value(address)") echo ${GCLB_IP}Per creare un mapping stabile e intuitivo all'indirizzo IP statico del bilanciatore del carico delle applicazioni, devi disporre di un record DNS pubblico. Puoi utilizzare qualsiasi provider DNS e automazione che preferisci. Questo deployment utilizza Endpoints 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}" EOFLa specifica YAML definisce il record DNS pubblico nel formato
frontend.endpoints.${PROJECT}.cloud.goog, dove${PROJECT}è il tuo identificatore di progetto univoco.Esegui il deployment del file
dns-spec.yamlnel tuo progetto Google Cloud :gcloud endpoints services deploy ${WORKDIR}/dns-spec.yamlL'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, utilizza i certificati TLS di Certificate Manager.
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-mapCollega il certificato alla mappa di certificati con una voce della 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"In Cloud Shell, esegui questo comando per creare il manifest
Gatewaycomegke-gateway.yaml:cat <<EOF > ${WORKDIR}/gke-gateway.yaml kind: Gateway apiVersion: gateway.networking.k8s.io/v1 metadata: name: external-http namespace: ingress-gateway 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 EOFApplica il manifest
Gatewayper creare unGatewaydenominatoexternal-http:kubectl apply -f ${WORKDIR}/gke-gateway.yamlCrea il file
HTTPRoute.yamlpredefinito:cat << EOF > ${WORKDIR}/default-httproute.yaml apiVersion: gateway.networking.k8s.io/v1 kind: HTTPRoute metadata: name: default-httproute namespace: ingress-gateway spec: parentRefs: - name: external-http namespace: ingress-gateway sectionName: https rules: - matches: - path: value: / backendRefs: - name: asm-ingressgateway port: 443 EOFApplica il valore predefinito
HTTPRoute:kubectl apply -f ${WORKDIR}/default-httproute.yamlCrea un file
HTTPRoute.yamlaggiuntivo per eseguire reindirizzamenti da HTTP a HTTP(S):cat << EOF > ${WORKDIR}/default-httproute-redirect.yaml kind: HTTPRoute apiVersion: gateway.networking.k8s.io/v1 metadata: name: http-to-https-redirect-httproute namespace: ingress-gateway spec: parentRefs: - name: external-http namespace: ingress-gateway sectionName: http rules: - filters: - type: RequestRedirect requestRedirect: scheme: https statusCode: 301 EOFApplica il reindirizzamento
HTTPRoute:kubectl apply -f ${WORKDIR}/default-httproute-redirect.yamlLa riconciliazione richiede tempo. Utilizza il seguente comando fino a
programmed=true:kubectl get gateway external-http -n ingress-gateway -wIn Cloud Shell, crea uno spazio dei nomi
onlineboutiquededicato:kubectl create namespace onlineboutiqueAggiungi un'etichetta allo spazio dei nomi
onlineboutique:kubectl label namespace onlineboutique istio-injection=enabledL'etichettatura dello spazio dei nomi
onlineboutiqueconistio-injection=enabledindica 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.yamlEsegui il deployment dell'app Online Boutique:
kubectl apply -f kubernetes-manifests.yaml -n onlineboutiqueWarning: 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 in esecuzione:
kubectl get pods -n onlineboutiqueL'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 qualche minuto affinché il cluster GKE Autopilot esegua il provisioning dell'infrastruttura di calcolo necessaria per supportare l'applicazione.
Esegui questo comando per creare il manifest
VirtualServicecomefrontend-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: - ingress-gateway/asm-ingressgateway http: - route: - destination: host: frontend port: number: 80 EOFVirtualServiceviene 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, quindiVirtualServiceviene eseguito il deployment dal proprietario dell'app.Esegui il deployment di
frontend-virtualservice.yamlnel tuo cluster:kubectl apply -f frontend-virtualservice.yamlAccedi al seguente link:
echo "https://frontend.endpoints.${PROJECT}.cloud.goog"Viene visualizzato il frontend di Online Boutique.
Per visualizzare i dettagli del certificato, fai clic su Visualizza informazioni sul sito nella barra degli indirizzi del browser, quindi fai clic su Certificato (valido).
Il visualizzatore di certificati mostra i dettagli del certificato gestito, inclusi la data di scadenza e l'emittente.
- In the Google Cloud console, go to the Manage resources page.
- In the project list, select the project that you want to delete, and then click Delete.
- In the dialog, type the project ID, and then click Shut down to delete the project.
In Cloud Shell, elimina le risorse
HTTPRoute:kubectl delete -f ${WORKDIR}/default-httproute-redirect.yaml kubectl delete -f ${WORKDIR}/default-httproute.yamlElimina la risorsa GKE Gateway:
kubectl delete -f ${WORKDIR}/gke-gateway.yamlElimina le risorse del certificato TLS (inclusa la voce della mappa dei certificati e la relativa mappa dei certificati principale):
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 --quietElimina la voce DNS di 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 --globalL'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_LOCATIONL'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].- Scopri di più sulle funzionalità offerte da GKE Ingress che puoi utilizzare con il tuo service mesh.
- Scopri di più sui diversi tipi di bilanciamento del carico cloud disponibili per GKE.
- Scopri di più sulle funzionalità offerte da Cloud Service Mesh.
- Scopri come eseguire il deployment di Ingress in più cluster GKE per il bilanciamento del carico multiregionale.
- Per ulteriori architetture di riferimento, diagrammi e best practice, esplora il Cloud Architecture Center.
Crea cluster GKE
Le funzionalità descritte in questo deployment richiedono un cluster GKE versione 1.16 o successive.
Installare un mesh di servizi
In questa sezione configuri Cloud Service Mesh gestito con l'API Fleet.
Esegui il deployment di GKE Gateway
Nei passaggi successivi, esegui il deployment del bilanciatore del carico delle applicazioni esterno tramite il controller GKE Gateway. La risorsa GKE Gateway automatizza il provisioning del bilanciatore del carico e il controllo di integrità del backend. Inoltre, utilizzi Certificate Manager 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 del mesh di servizi
Come best practice di sicurezza, ti consigliamo di eseguire il deployment del gateway in entrata in uno spazio dei nomi diverso dal control plane.
Applica un controllo di integrità del gateway di ingresso del mesh di servizi
Quando integri un gateway in entrata del mesh di servizi a un bilanciatore del carico delle applicazioni Google Cloud , quest'ultimo deve essere configurato per eseguire controlli di integrità sui pod del gateway in entrata. Il CRD HealthCheckPolicy
fornisce un'API per configurare il controllo di integrità.
Definisci criteri di sicurezza
Cloud Armor offre protezione DDoS e criteri di sicurezza personalizzabili che puoi collegare a un bilanciatore del carico tramite risorse Ingress. Nei passaggi seguenti, crei una policy di sicurezza che utilizza regole preconfigurate per bloccare gli attacchi cross-site scripting (XSS). Questa regola consente di bloccare il traffico che corrisponde a firme di attacco note, ma consente tutto il resto del traffico. Il tuo ambiente potrebbe utilizzare regole diverse a seconda del carico di lavoro.
Configura l'indirizzamento IP e il DNS
Provisioning di un certificato TLS
In questa sezione, crei un certificato TLS utilizzando Certificate Manager e lo associ a una mappa dei certificati tramite una voce della mappa dei certificati. Il bilanciatore del carico delle applicazioni, configurato tramite GKE Gateway, utilizza il certificato per fornire comunicazioni sicure tra il client e Google Cloud. Una volta creata, la voce della mappa dei certificati viene referenziata dalla risorsa GKE Gateway.
Esegui il deployment delle risorse GKE Gateway e HTTPRoute
In questa sezione configuri la risorsa GKE Gateway
che esegue il provisioning del bilanciatore del carico delle applicazioni utilizzando
gke-l7-global-external-managed
gatewayClass. Google Cloud
Inoltre, configuri le risorse HTTPRoute che indirizzano le richieste all'applicazione ed eseguono reindirizzamenti da HTTP a HTTP(S).
Installa l'app di esempio Online Boutique
Ora hai un bilanciatore del carico HTTPS globale che funge da frontend per l'applicazione ospitata nel service mesh.
Esegui la pulizia
Al termine del deployment, puoi eseguire la pulizia delle risorse create su Google Cloud in modo che non vengano addebitate in futuro. Puoi eliminare l'intero progetto oppure eliminare le risorse del cluster e poi eliminare il cluster.
Elimina il progetto
Elimina le singole risorse
Se vuoi conservare il progetto Google Cloud che hai utilizzato in questo deployment, elimina le singole risorse: