En esta implementación se muestra cómo combinar Cloud Service Mesh con Cloud Load Balancing para exponer aplicaciones de una malla de servicios a clientes de Internet.
Puedes exponer una aplicación a los clientes de muchas formas, en función de dónde se encuentre el cliente. En este despliegue se muestra cómo exponer una aplicación a los clientes combinando Cloud Load Balancing con Cloud Service Mesh para integrar balanceadores de carga con una malla de servicios. Esta implementación está pensada para usuarios avanzados que ejecutan Cloud Service Mesh, pero también funciona con Istio en Google Kubernetes Engine.
Arquitectura
En el siguiente diagrama se muestra cómo puedes usar las pasarelas de entrada de malla para integrar balanceadores de carga con una malla de servicios:
En la topología del diagrama anterior, la capa de entrada en la nube, que se programa a través de GKE Gateway, obtiene tráfico de fuera de la malla de servicios y lo dirige a la capa de entrada de la malla. A continuación, la capa de entrada de la malla dirige el tráfico a los backends de la aplicación alojada en la malla.
La topología anterior tiene las siguientes consideraciones:
- Ingreso en la nube: en esta arquitectura de referencia, se configura el Google Cloud balanceador de carga a través de GKE Gateway para comprobar el estado de los proxies de ingreso de la malla en sus puertos de comprobación del estado expuestos.
- Ingreso de malla: en la aplicación de malla, realizas comprobaciones de estado en los backends directamente para poder ejecutar el balanceo de carga y la gestión del tráfico de forma local.
En el diagrama anterior se ilustra el cifrado HTTPS desde el cliente hasta el Google Cloud balanceador de carga, desde el balanceador de carga hasta el proxy de entrada de la malla y desde el proxy de entrada hasta el proxy sidecar.
Objetivos
- Despliega un clúster de Google Kubernetes Engine (GKE) en Google Cloud.
- Despliega una malla de servicios de Cloud basada en Istio en tu clúster de GKE.
- Configura la puerta de enlace de GKE para que termine el tráfico HTTPS público y lo dirija a las aplicaciones alojadas en la malla de servicios.
- Despliega la aplicación Online Boutique en el clúster de GKE que expones a los clientes en Internet.
Optimización de costes
En este documento, se utilizan los siguientes componentes facturables de Google Cloud:
- Google Kubernetes Engine
- Compute Engine
- Cloud Load Balancing
- Certificate Manager
- Cloud Service Mesh
- Google Cloud Armor
- Cloud Endpoints
Para generar una estimación de costes basada en el uso previsto,
utiliza la calculadora de precios.
Cuando termines las tareas que se describen en este documento, puedes evitar que se te siga facturando eliminando los recursos que has creado. Para obtener más información, consulta la sección Limpiar.
Antes de empezar
-
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.
Todos los comandos de terminal de este despliegue se ejecutan desde Cloud Shell.
Actualiza a la versión más reciente de Google Cloud CLI:
gcloud components updateConfigura tu Google Cloud proyecto predeterminado:
export PROJECT=PROJECT export PROJECT_NUMBER=$(gcloud projects describe ${PROJECT} --format="value(projectNumber)") gcloud config set project ${PROJECT}Sustituye
PROJECTpor el ID del proyecto que quieras usar en esta implementación.Crea un directorio de trabajo:
mkdir -p ${HOME}/edge-to-mesh cd ${HOME}/edge-to-mesh export WORKDIR=`pwd`Una vez que haya completado esta implementación, puede eliminar el directorio de trabajo.
En Cloud Shell, crea un archivo
kubeconfig. De esta forma, te aseguras de que no se produzca un conflicto con el archivokubeconfig(predeterminado) que ya tienes.touch edge2mesh_kubeconfig export KUBECONFIG=${WORKDIR}/edge2mesh_kubeconfigDefine las variables de entorno del clúster de GKE:
export CLUSTER_NAME=edge-to-mesh export CLUSTER_LOCATION=us-central1Habilita la API de Google Kubernetes Engine:
gcloud services enable container.googleapis.comCrea un clúster de Autopilot de GKE:
gcloud container --project ${PROJECT} clusters create-auto \ ${CLUSTER_NAME} --region ${CLUSTER_LOCATION} --release-channel rapidAsegúrate de que el clúster se esté ejecutando:
gcloud container clusters listEl resultado debería ser similar al siguiente:
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
En Cloud Shell, habilita las APIs necesarias:
gcloud services enable mesh.googleapis.comHabilita Cloud Service Mesh en la flota:
gcloud container fleet mesh enableRegistra el clúster en la flota:
gcloud container fleet memberships register ${CLUSTER_NAME} \ --gke-cluster ${CLUSTER_LOCATION}/${CLUSTER_NAME}Aplica la etiqueta
mesh_idal clústeredge-to-mesh:gcloud container clusters update ${CLUSTER_NAME} --project ${PROJECT} --region ${CLUSTER_LOCATION} --update-labels mesh_id=proj-${PROJECT_NUMBER}Habilita la gestión automática del plano de control y el plano de datos gestionado:
gcloud container fleet mesh update \ --management automatic \ --memberships ${CLUSTER_NAME}Al cabo de unos minutos, comprueba que el estado del plano de control sea
ACTIVE:gcloud container fleet mesh describeEl resultado debería ser similar al siguiente:
... 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 ...En Cloud Shell, crea un espacio de nombres
ingress-gatewayespecífico:kubectl create namespace ingress-gatewayAñade una etiqueta de espacio de nombres al espacio de nombres
ingress-gateway:kubectl label namespace ingress-gateway istio-injection=enabledEl resultado debería ser similar al siguiente:
namespace/ingress-gateway labeled
Al etiquetar el espacio de nombres
ingress-gatewayconistio-injection=enabled, se indica a Cloud Service Mesh que inserte automáticamente proxies sidecar de Envoy cuando se despliegue una aplicación.Crea un certificado autofirmado que utilice la pasarela de entrada para finalizar las conexiones TLS entre el balanceador de carga (que se configurará más adelante mediante el controlador de GKE Gateway) y la pasarela de entrada, y almacena el certificado autofirmado como un secreto de Kubernetes: Google Cloud
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.crtPara obtener más información sobre los requisitos del certificado de la pasarela de entrada, consulta la guía de consideraciones sobre el protocolo de backend seguro.
Ejecuta los siguientes comandos para crear el archivo YAML del recurso de la pasarela de entrada:
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 EOFAplica los CRDs de la pasarela de entrada:
kubectl apply -k ${WORKDIR}/ingress-gateway/variantAsegúrate de que todas las implementaciones estén activas y en funcionamiento:
kubectl wait --for=condition=available --timeout=600s deployment --all -n ingress-gatewayEl resultado debería ser similar al siguiente:
deployment.apps/asm-ingressgateway condition met
En Cloud Shell, crea el archivo
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 EOFAplica la
HealthCheckPolicy:kubectl apply -f ${WORKDIR}/ingress-gateway-healthcheck.yamlEn Cloud Shell, crea una política de seguridad llamada
edge-fw-policy:gcloud compute security-policies create edge-fw-policy \ --description "Block XSS attacks"Crea una regla de política de seguridad que use los filtros XSS preconfigurados:
gcloud compute security-policies rules create 1000 \ --security-policy edge-fw-policy \ --expression "evaluatePreconfiguredExpr('xss-stable')" \ --action "deny-403" \ --description "XSS attack filtering"Crea el archivo
GCPBackendPolicy.yamlpara adjuntarlo al servicio de puerta de enlace de entrada: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 EOFAplica el archivo
GCPBackendPolicy.yaml:kubectl apply -f ${WORKDIR}/cloud-armor-backendpolicy.yamlEn Cloud Shell, crea una dirección IP estática global para el balanceador de cargaGoogle Cloud :
gcloud compute addresses create e2m-gclb-ip --globalEl recurso de pasarela de GKE usa esta dirección IP estática, lo que permite que la dirección IP siga siendo la misma aunque cambie el balanceador de carga externo.
Obtén la dirección IP estática:
export GCLB_IP=$(gcloud compute addresses describe e2m-gclb-ip \ --global --format "value(address)") echo ${GCLB_IP}Para crear una asignación estable y fácil de usar a la dirección IP estática de tu balanceador de carga de aplicaciones, debes tener un registro DNS público. Puedes usar el proveedor de DNS y la automatización que quieras. Esta implementación usa Endpoints en lugar de crear una zona DNS gestionada. Endpoints proporciona un registro DNS gestionado por Google gratuito para una dirección IP pública.
Ejecuta el siguiente comando para crear el archivo de especificación YAML llamado
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 especificación YAML define el registro DNS público con el formato
frontend.endpoints.${PROJECT}.cloud.goog, donde${PROJECT}es el identificador único de tu proyecto.Despliega el archivo
dns-spec.yamlen tu Google Cloud proyecto:gcloud endpoints services deploy ${WORKDIR}/dns-spec.yamlEl resultado debería ser similar al siguiente:
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]
Ahora que la dirección IP y el DNS están configurados, puedes generar un certificado público para proteger el frontend. Para integrarlo con GKE Gateway, utiliza certificados TLS de Certificate Manager.
En Cloud Shell, habilita la API Certificate Manager:
gcloud services enable certificatemanager.googleapis.com --project=${PROJECT}Crea el certificado TLS:
gcloud --project=${PROJECT} certificate-manager certificates create edge2mesh-cert \ --domains="frontend.endpoints.${PROJECT}.cloud.goog"Crea el mapeado de certificados:
gcloud --project=${PROJECT} certificate-manager maps create edge2mesh-cert-mapAdjunta el certificado al mapa de certificados con una entrada de mapa de certificados:
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"En Cloud Shell, ejecuta el siguiente comando para crear el manifiesto
Gatewaycomogke-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 EOFAplica el manifiesto
Gatewaypara crear unGatewayllamadoexternal-http:kubectl apply -f ${WORKDIR}/gke-gateway.yamlCrea el archivo
HTTPRoute.yamlpredeterminado: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 EOFAplica el valor predeterminado
HTTPRoute:kubectl apply -f ${WORKDIR}/default-httproute.yamlCrea un archivo
HTTPRoute.yamladicional para realizar redirecciones de 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 EOFAplica la redirección
HTTPRoute:kubectl apply -f ${WORKDIR}/default-httproute-redirect.yamlLa conciliación lleva tiempo. Usa el siguiente comando hasta
programmed=true:kubectl get gateway external-http -n ingress-gateway -wEn Cloud Shell, crea un espacio de nombres
onlineboutiqueespecífico:kubectl create namespace onlineboutiqueAñade una etiqueta al espacio de nombres
onlineboutique:kubectl label namespace onlineboutique istio-injection=enabledAl etiquetar el espacio de nombres
onlineboutiqueconistio-injection=enabled, se indica a Cloud Service Mesh que inserte automáticamente proxies sidecar de Envoy cuando se despliegue una aplicación.Descarga los archivos YAML de Kubernetes de la aplicación de ejemplo Online Boutique:
curl -LO \ https://raw.githubusercontent.com/GoogleCloudPlatform/microservices-demo/main/release/kubernetes-manifests.yamlImplementa la aplicación Online Boutique:
kubectl apply -f kubernetes-manifests.yaml -n onlineboutiqueEl resultado es similar al siguiente (incluidas las advertencias sobre la configuración predeterminada de solicitudes y límites de recursos de Autopilot de GKE):
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 ...Asegúrate de que todas las implementaciones estén activas y en funcionamiento:
kubectl get pods -n onlineboutiqueEl resultado debería ser similar al siguiente:
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 ...Espera unos minutos a que el clúster de Autopilot de GKE aprovisione la infraestructura de computación necesaria para admitir la aplicación.
Ejecuta el siguiente comando para crear el manifiesto
VirtualServicecomofrontend-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 EOFVirtualServicese crea en el espacio de nombres de la aplicación (onlineboutique). Normalmente, el propietario de la aplicación decide y configura cómo y qué tráfico se enruta a la aplicaciónfrontend, por lo que el propietario de la aplicación implementaVirtualService.Despliega
frontend-virtualservice.yamlen tu clúster:kubectl apply -f frontend-virtualservice.yamlAccede al siguiente enlace:
echo "https://frontend.endpoints.${PROJECT}.cloud.goog"Se muestra el frontend de Online Boutique.
Para ver los detalles de su certificado, haga clic en Ver información del sitio en la barra de direcciones de su navegador y, a continuación, en Certificado (Válido).
El visor de certificados muestra los detalles del certificado gestionado, como la fecha de vencimiento y la entidad emisora.
- 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.
En Cloud Shell, elimina los recursos
HTTPRoute:kubectl delete -f ${WORKDIR}/default-httproute-redirect.yaml kubectl delete -f ${WORKDIR}/default-httproute.yamlElimina el recurso de pasarela de GKE:
kubectl delete -f ${WORKDIR}/gke-gateway.yamlElimina los recursos del certificado TLS (incluida la entrada del mapa de certificados y su mapa de certificados principal):
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 entrada DNS de Endpoints:
gcloud endpoints services delete "frontend.endpoints.${PROJECT}.cloud.goog"El resultado debería ser similar al siguiente:
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.
Cuando se te pida que continúes, escribe Y.
El resultado debería ser similar al siguiente:
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 la dirección IP estática:
gcloud compute addresses delete ingress-ip --globalEl resultado debería ser similar al siguiente:
The following global addresses will be deleted: - [ingress-ip]
Cuando se te pida que continúes, escribe Y.
El resultado debería ser similar al siguiente:
Deleted [https://www.googleapis.com/compute/v1/projects/edge2mesh/global/addresses/ingress-ip].
Elimina el clúster de GKE:
gcloud container clusters delete $CLUSTER_NAME --zone $CLUSTER_LOCATIONEl resultado debería ser similar al siguiente:
The following clusters will be deleted. - [edge-to-mesh] in [us-central1]Cuando se te pida que continúes, escribe Y.
Al cabo de unos minutos, el resultado será similar al siguiente:
Deleting cluster edge-to-mesh...done. Deleted [https://container.googleapis.com/v1/projects/e2m-doc-01/zones/us-central1/clusters/edge-to-mesh].- Consulta más funciones que ofrece GKE Ingress y que puedes usar con tu malla de servicios.
- Consulta los distintos tipos de balanceo de carga en la nube disponibles para GKE.
- Consulta las características y funciones que ofrece Cloud Service Mesh.
- Consulta cómo desplegar Ingress en varios clústeres de GKE para el balanceo de carga multirregional.
- Para ver más arquitecturas de referencia, diagramas y prácticas recomendadas, consulta el centro de arquitectura de Cloud.
Crear clústeres de GKE
Las funciones que se describen en esta implementación requieren un clúster de GKE con la versión 1.16 o posterior.
Instalar una malla de servicios
En esta sección, configurará Cloud Service Mesh gestionado con la API de flota.
Desplegar una pasarela de GKE
En los siguientes pasos, desplegarás el balanceador de carga de aplicación externo a través del controlador de GKE Gateway. El recurso Gateway de GKE automatiza el aprovisionamiento del balanceador de carga y la comprobación del estado del backend. Además, puedes usar Certificate Manager para aprovisionar y gestionar un certificado TLS, y Endpoints para aprovisionar automáticamente un nombre de DNS público para la aplicación.
Instalar una pasarela de entrada de malla de servicios
Como medida de seguridad recomendada, te aconsejamos que implementes la pasarela de entrada en un espacio de nombres diferente al del plano de control.
Aplicar una comprobación del estado de la pasarela de entrada de la malla de servicios
Cuando se integra una pasarela de entrada de malla de servicios en un balanceador de carga de aplicaciones, este debe configurarse para realizar comprobaciones de estado en los pods de la pasarela de entrada. Google Cloud El CRD HealthCheckPolicy proporciona una API para configurar esa comprobación del estado.
Definir políticas de seguridad
Cloud Armor proporciona defensa contra ataques DDoS y políticas de seguridad personalizables que puedes asociar a un balanceador de carga mediante recursos Ingress. En los pasos siguientes, creará una política de seguridad que utilice reglas preconfiguradas para bloquear ataques de cross-site scripting (XSS). Esta regla ayuda a bloquear el tráfico que coincide con firmas de ataques conocidas, pero permite todo el tráfico restante. Tu entorno puede usar reglas diferentes en función de tu carga de trabajo.
Configurar el direccionamiento IP y el DNS
Proporcionar un certificado TLS
En esta sección, creará un certificado TLS con Certificate Manager y lo asociará a un mapa de certificados mediante una entrada de mapa de certificados. El balanceador de carga de aplicaciones, configurado a través de GKE Gateway, usa el certificado para proporcionar comunicaciones seguras entre el cliente y Google Cloud. Una vez creada, la entrada del mapa de certificados se hace referencia al recurso de la puerta de enlace de GKE.
Desplegar los recursos de GKE Gateway y HTTPRoute
En esta sección, configurará el recurso de GKE Gateway
que aprovisiona el balanceador de carga de la aplicación mediante el
gke-l7-global-external-managed
gatewayClass. Google Cloud
Además, puedes configurar HTTPRoute
recursos que enruten las solicitudes a la aplicación y realicen redirecciones de HTTP a
HTTP(S).
Instalar la aplicación de ejemplo Online Boutique
Ahora tienes un balanceador de carga HTTPS global que actúa como frontend de tu aplicación alojada en service mesh.
Limpieza
Una vez que hayas completado la implementación, puedes eliminar los recursos que has creado en Google Cloud para que no se te facturen en el futuro. Puedes eliminar el proyecto por completo o eliminar los recursos del clúster y, a continuación, eliminar el clúster.
Eliminar el proyecto
Eliminar los recursos concretos
Si quieres conservar el Google Cloud proyecto que has usado en esta implementación, elimina los recursos individuales: