Ce déploiement explique comment combiner Anthos Service Mesh à Cloud Load Balancing pour exposer les applications d'un maillage de services à des clients Internet.
Vous pouvez exposer une application à des clients de différentes manières selon l'emplacement des clients. Ce déploiement explique comment exposer une application à des clients en associant Cloud Load Balancing à Anthos Service Mesh afin d'intégrer des équilibreurs de charge à un maillage de services. Ce déploiement s'adresse aux professionnels avancés qui utilisent Anthos Service Mesh, mais il fonctionne également pour Istio sur Google Kubernetes Engine.
Architecture
Le schéma suivant montre comment utiliser des passerelles d'entrée de maillage pour intégrer des équilibreurs de charge à un maillage de services :
Dans la topologie du schéma précédent, la couche d'entrée cloud, programmée via GKE Gateway, récupère le trafic depuis l'extérieur du maillage de services et le dirige vers la couche d'entrée du maillage. La couche d'entrée du maillage dirige ensuite le trafic vers les backends d'application hébergés par le maillage.
La topologie précédente implique les considérations suivantes :
- Entrée cloud : dans cette architecture de référence, vous configurez l'équilibreur de charge Google Cloud via GKE Gateway pour qu'il vérifie l'état des proxys d'entrée du maillage sur leurs ports de vérification d'état exposés.
- Entrée de maillage : dans l'application de maillage, vous effectuez directement les vérifications de l'état des backends afin de pouvoir exécuter l'équilibrage de charge et gérer le trafic localement.
Le schéma précédent illustre le chiffrement HTTPS du client vers l'équilibreur de charge Google Cloud, de l'équilibreur de charge vers le proxy d'entrée du maillage, et du proxy d'entrée vers le proxy side-car.
Objectifs
- Déployer un cluster Google Kubernetes Engine (GKE) sur Google Cloud.
- Déployer un service Anthos Service Mesh basé sur Istio sur votre cluster GKE.
- Configurer GKE Gateway pour arrêter le trafic HTTPS public et le diriger vers des applications hébergées par le maillage de services.
- Déployer l'application Boutique en ligne sur le cluster GKE que vous exposez à des clients sur Internet.
Optimisation des coûts
Dans ce document, vous utilisez les composants facturables suivants de Google Cloud :
- Google Kubernetes Engine
- Compute Engine
- Cloud Load Balancing
- Gestionnaire de certificats
- Anthos Service Mesh
- Google Cloud Armor
- Cloud Endpoints
Obtenez une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût.
Une fois que vous avez terminé les tâches décrites dans ce document, vous pouvez éviter de continuer à payer des frais en supprimant les ressources que vous avez créées. Pour en savoir plus, consultez la section Effectuer un nettoyage.
Avant de commencer
-
Dans Google Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Google Cloud.
-
Vérifiez que la facturation est activée pour votre projet Google Cloud.
-
Dans la console Google Cloud, activez Cloud Shell.
Vous exécutez toutes les commandes de terminal de ce déploiement depuis Cloud Shell.
Passez à la dernière version de Google Cloud CLI :
gcloud components updateDéfinissez votre projet Google Cloud par défaut :
export PROJECT=PROJECT export PROJECT_NUMBER=$(gcloud projects describe ${PROJECT} --format="value(projectNumber)") gcloud config set project ${PROJECT}Remplacez
PROJECTpar l'ID de projet que vous souhaitez utiliser pour ce déploiement.Créez un répertoire de travail :
mkdir -p ${HOME}/edge-to-mesh cd ${HOME}/edge-to-mesh export WORKDIR=`pwd`Une fois ce déploiement terminé, vous pouvez supprimer le répertoire de travail.
Créer des clusters GKE
Les fonctionnalités décrites dans ce déploiement nécessitent un cluster GKE version 1.16 ou ultérieure.
Dans Cloud Shell, créez un fichier
kubeconfig. Cette étape vous permet de ne pas créer de conflit avec votre fichierkubeconfig(par défaut) existant.touch edge2mesh_kubeconfig export KUBECONFIG=${WORKDIR}/edge2mesh_kubeconfigDéfinissez des variables d'environnement pour le cluster GKE :
export CLUSTER_NAME=edge-to-mesh export CLUSTER_LOCATION=us-central1Activez l'API Google Kubernetes Engine :
gcloud services enable container.googleapis.comCréez un cluster GKE Autopilot :
gcloud container --project ${PROJECT} clusters create-auto ${CLUSTER_NAME} --region ${CLUSTER_LOCATION} --release-channel rapidAssurez-vous que le cluster est en cours d'exécution :
gcloud container clusters listLe résultat ressemble à ce qui suit :
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
Installer un maillage de services
Dans cette section, vous configurez le service Anthos Service Mesh géré avec l'API Fleet.
Dans Cloud Shell, activez les API nécessaires :
gcloud services enable mesh.googleapis.comActivez Anthos Service Mesh dans le parc :
gcloud container fleet mesh enableEnregistrez le cluster dans le parc :
gcloud container fleet memberships register ${CLUSTER_NAME} \ --gke-cluster ${CLUSTER_LOCATION}/${CLUSTER_NAME}Appliquez le libellé
mesh_idau clusteredge-to-mesh:gcloud container clusters update ${CLUSTER_NAME} --project ${PROJECT} --region ${CLUSTER_LOCATION} --update-labels mesh_id=proj-${PROJECT_NUMBER}Activez la gestion automatique du plan de contrôle et le plan de données géré :
gcloud container fleet mesh update \ --management automatic \ --memberships ${CLUSTER_NAME}Après quelques minutes, vérifiez que l'état du plan de contrôle est
ACTIVE:gcloud container fleet mesh describeLe résultat ressemble à ce qui suit :
... 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 ...
Déployer GKE Gateway
Dans les étapes suivantes, vous allez déployer l'équilibreur de charge d'application externe via le GKE Gateway Controller. La ressource GKE Gateway automatise le provisionnement de l'équilibreur de charge et la vérification d'état du backend. De plus, vous utilisez le gestionnaire de certificats pour provisionner et gérer un certificat TLS, et les points de terminaison pour provisionner automatiquement un nom DNS public pour l'application.
Installer une passerelle d'entrée du maillage de services
Pour des raisons de sécurité, nous vous recommandons de déployer la passerelle d'entrée dans un espace de noms différent du plan de contrôle.
Dans Cloud Shell, créez un espace de noms
asm-ingressdédié :kubectl create namespace asm-ingressAjoutez un libellé d'espace de noms à l'espace de noms
asm-ingress:kubectl label namespace asm-ingress istio-injection=enabledLe résultat ressemble à ce qui suit :
namespace/asm-ingress labeled
L'ajout d'un libellé
istio-injection=enabledà l'espace de nomsasm-ingressindique à Anthos Service Mesh d'injecter automatiquement des proxys side-car Envoy lors du déploiement d'une application.Créez un certificat autosigné utilisé par la passerelle d'entrée pour interrompre les connexions TLS entre l'équilibreur de charge Google Cloud (à configurer ultérieurement via GKE Gateway Controller) et la passerelle d'entrée, puis stocker le certificat autosigné en tant que 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 asm-ingress create secret tls edge2mesh-credential \ --key=frontend.endpoints.${PROJECT}.cloud.goog.key \ --cert=frontend.endpoints.${PROJECT}.cloud.goog.crtPour plus d'informations sur les exigences liées au certificat de passerelle d'entrée, consultez le guide sur les protocoles de backend sécurisé.
Exécutez les commandes suivantes pour créer le fichier YAML de ressource de passerelle d'entrée :
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 EOFAppliquez les CRD de passerelle d'entrée :
kubectl apply -k ${WORKDIR}/asm-ig/variantAssurez-vous que tous les déploiements sont opérationnels :
kubectl wait --for=condition=available --timeout=600s deployment --all -n asm-ingressLe résultat ressemble à ce qui suit :
deployment.apps/asm-ingressgateway condition met
Appliquer une vérification d'état à la passerelle d'entrée du maillage de services
Lors de l'intégration d'une passerelle d'entrée de maillage de services à un équilibreur de charge d'application Google Cloud, celui-ci doit être configuré pour effectuer des vérifications d'état sur les pods de la passerelle d'entrée. L'objet CRD HealthCheckPolicy fournit une API permettant de configurer cette vérification d'état.
Dans Cloud Shell, créez le fichier
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 EOFAppliquer la fonction
HealthCheckPolicy:kubectl apply -f ${WORKDIR}/ingress-gateway-healthcheck.yaml
Définir des règles de sécurité
Google Cloud Armor fournit une défense contre les attaques DDoS et des règles de sécurité personnalisables que vous pouvez associer à un équilibreur de charge via des ressources Ingress. Dans les étapes suivantes, vous créez une règle de sécurité qui utilise des règles préconfigurées pour bloquer les attaques de script intersites (XSS). Cette règle bloque le trafic correspondant aux signatures d'attaque connues, mais autorise tout autre trafic. Votre environnement peut utiliser des règles différentes en fonction de votre charge de travail.
Dans Cloud Shell, créez une règle de sécurité appelée
edge-fw-policy:gcloud compute security-policies create edge-fw-policy \ --description "Block XSS attacks"Créez une règle de sécurité qui utilise les filtres XSS préconfigurés :
gcloud compute security-policies rules create 1000 \ --security-policy edge-fw-policy \ --expression "evaluatePreconfiguredExpr('xss-stable')" \ --action "deny-403" \ --description "XSS attack filtering"Créez le fichier
GCPBackendPolicy.yamlà associer au service de passerelle d'entrée :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 EOFAppliquez le fichier
GCPBackendPolicy.yaml:kubectl apply -f ${WORKDIR}/cloud-armor-backendpolicy.yaml
Configurer l'adressage IP et DNS
Dans Cloud Shell, créez une adresse IP statique globale pour l'équilibreur de charge Google Cloud :
gcloud compute addresses create e2m-gclb-ip --globalCette adresse IP statique est utilisée par la ressource GKE Gateway et permet à l'adresse IP de rester identique, même si l'équilibreur de charge externe est modifié.
Obtenez l'adresse IP statique :
export GCLB_IP=$(gcloud compute addresses describe e2m-gclb-ip --global --format "value(address)") echo ${GCLB_IP}Pour créer un mappage stable et lisible avec l'adresse IP statique de l'équilibreur de charge de votre application, vous devez disposer d'un enregistrement DNS public. Vous pouvez utiliser le fournisseur DNS de votre choix et l'automatisation de votre choix. Ce déploiement utilise les points de terminaison au lieu de créer une zone DNS gérée. Les points de terminaison offrent un enregistrement DNS géré par Google gratuit pour une adresse IP publique.
Exécutez la commande suivante pour créer le fichier de spécification YAML nommé
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 spécification YAML définit l'enregistrement DNS public sous la forme
frontend.endpoints.${PROJECT}.cloud.goog, où${PROJECT}est votre identifiant de projet unique.Déployez le fichier
dns-spec.yamldans votre projet Google Cloud :gcloud endpoints services deploy ${WORKDIR}/dns-spec.yamlLe résultat ressemble à ce qui suit :
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]
Maintenant que l'adresse IP et les DNS sont configurés, vous pouvez générer un certificat public pour sécuriser l'interface. Pour l'intégration à GKE Gateway, vous devez utiliser des certificats TLS du gestionnaire de certificats.
Provisionner un certificat TLS
Dans cette section, vous allez créer un certificat TLS à l'aide du gestionnaire de certificats et l'associer à un mappage de certificats via une entrée de mappage de certificats. L'équilibreur de charge d'application, configuré via GKE Gateway, utilise le certificat pour fournir des communications sécurisées entre le client et Google Cloud. Une fois créée, l'entrée de mappage de certificat est référencée par la ressource GKE Gateway.
Dans Cloud Shell, activez l'API Certificate Manager :
gcloud services enable certificatemanager.googleapis.com --project=${PROJECT}Créez le certificat TLS :
gcloud --project=${PROJECT} certificate-manager certificates create edge2mesh-cert \ --domains="frontend.endpoints.${PROJECT}.cloud.goog"Créez le mappage de certificat :
gcloud --project=${PROJECT} certificate-manager maps create edge2mesh-cert-mapAssociez le certificat au mappage de certificats avec une entrée de mappage de certificat :
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"
Déployer la passerelle GKE Gateway et les ressources HTTPRoute
Dans cette section, vous allez configurer la ressource GKE Gateway qui provisionne l'équilibreur de charge de l'application Google Cloud à l'aide de gke-l7-global-external-managed
gatewayClass.
En outre, vous configurez des ressources HTTPRoute qui acheminent les requêtes vers l'application et effectuent des redirections HTTP vers HTTP(S).
Dans Cloud Shell, exécutez la commande suivante pour créer le fichier manifeste
Gatewaysous le nomgke-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 EOFAppliquez le fichier manifeste
Gatewaypour créer un objetGatewayappeléexternal-http:kubectl apply -f ${WORKDIR}/gke-gateway.yamlCréez le fichier
HTTPRoute.yamlpar défaut :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 EOFAppliquez la valeur par défaut
HTTPRoute:kubectl apply -f ${WORKDIR}/default-httproute.yamlCréez un fichier
HTTPRoute.yamlsupplémentaire pour effectuer des redirections HTTP vers 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 EOFAppliquez la redirection
HTTPRoute:kubectl apply -f ${WORKDIR}/default-httproute-redirect.yamlLe rapprochement prend du temps. Exécutez la commande suivante jusqu'à ce que
programmed=true:kubectl get gateway external-http -n asm-ingress -w
Installer l'exemple d'application Online Boutique
Dans Cloud Shell, créez un espace de noms
onlineboutiquedédié :kubectl create namespace onlineboutiqueAjoutez un libellé à l'espace de noms
onlineboutique:kubectl label namespace onlineboutique istio-injection=enabledL'ajout d'un libellé
istio-injection=enabledà l'espace de nomsonlineboutiqueindique à Anthos Service Mesh d'injecter automatiquement des proxys side-car Envoy lors du déploiement d'une application.Téléchargez les fichiers YAML Kubernetespour l'exemple d'application Boutique en ligne :
curl -LO \ https://raw.githubusercontent.com/GoogleCloudPlatform/microservices-demo/main/release/kubernetes-manifests.yamlDéployez l'application Boutique en ligne :
kubectl apply -f kubernetes-manifests.yaml -n onlineboutiqueLe résultat ressemble à ce qui suit (y compris des avertissements concernant la définition de demandes et de limites de ressources par défaut dans 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 ...Assurez-vous que tous les déploiements sont opérationnels :
kubectl get pods -n onlineboutiqueLe résultat ressemble à ce qui suit :
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 ...Attendez quelques minutes que le cluster GKE Autopilot provisionne l'infrastructure de calcul nécessaire à la prise en charge de l'application.
Exécutez la commande suivante pour créer le fichier manifeste
VirtualServiceen tant quefrontend-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 EOFVirtualServiceest créé dans l'espace de noms de l'application (onlineboutique). En règle générale, le propriétaire de l'application choisit et configure le mode de routage du trafic vers l'applicationfrontendafin de déployerVirtualService.Déployez
frontend-virtualservice.yamldans votre cluster :kubectl apply -f frontend-virtualservice.yamlCliquez sur le lien suivant :
echo "https://frontend.endpoints.${PROJECT}.cloud.goog"L'interface de votre boutique en ligne s'affiche.
Pour afficher les détails de votre certificat, cliquez sur Afficher les informations sur le site dans la barre d'adresse de votre navigateur, puis cliquez sur Certificat (valide).
La visionneuse de certificats affiche les détails du certificat géré, y compris la date d'expiration et l'auteur.
Vous disposez maintenant d'un équilibreur de charge HTTPS global servant d'interface à votre application hébergée par le maillage de services.
Effectuer un nettoyage
Une fois que vous avez terminé le déploiement, vous pouvez nettoyer les ressources que vous avez créées sur Google Cloud afin qu'elles ne vous soient plus facturées. Vous pouvez soit supprimer entièrement le projet, soit supprimer les ressources du cluster, puis le supprimer.
Supprimer le projet
- Dans la console Google Cloud, accédez à la page Gérer les ressources.
- Dans la liste des projets, sélectionnez le projet que vous souhaitez supprimer, puis cliquez sur Supprimer.
- Dans la boîte de dialogue, saisissez l'ID du projet, puis cliquez sur Arrêter pour supprimer le projet.
Supprimer les ressources individuelles
Si vous souhaitez conserver le projet Google Cloud que vous avez utilisé dans ce déploiement, supprimez les différentes ressources.
Dans Cloud Shell, supprimez les ressources
HTTPRoute:kubectl delete -f ${WORKDIR}/default-httproute-redirect.yaml kubectl delete -f ${WORKDIR}/default-httproute.yamlSupprimez la ressource GKE Gateway :
kubectl delete -f ${WORKDIR}/gke-gateway.yamlSupprimez les ressources de certificat TLS (y compris l'entrée de mappage de certificat et son mappage de certificat parent) :
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 --quietSupprimez l'entrée Endpoints DNS :
gcloud endpoints services delete "frontend.endpoints.${PROJECT}.cloud.goog"Le résultat ressemble à ce qui suit :
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.
Lorsque vous êtes invité à continuer, saisissez Y.
Le résultat ressemble à ce qui suit :
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
Supprimez l'adresse IP statique :
gcloud compute addresses delete ingress-ip --globalLe résultat ressemble à ce qui suit :
The following global addresses will be deleted: - [ingress-ip]
Lorsque vous êtes invité à continuer, saisissez Y.
Le résultat ressemble à ce qui suit :
Deleted [https://www.googleapis.com/compute/v1/projects/edge2mesh/global/addresses/ingress-ip].
Supprimez le cluster GKE :
gcloud container clusters delete $CLUSTER_NAME --zone $CLUSTER_LOCATIONLe résultat ressemble à ce qui suit :
The following clusters will be deleted. - [edge-to-mesh] in [us-central1]Lorsque vous êtes invité à continuer, saisissez Y.
Après quelques minutes, le résultat est semblable à celui-ci :
Deleting cluster edge-to-mesh...done. Deleted [https://container.googleapis.com/v1/projects/e2m-doc-01/zones/us-central1/clusters/edge-to-mesh].
Étapes suivantes
- Découvrez les autres fonctionnalités offertes par GKE Ingress que vous pouvez utiliser avec votre maillage de services.
- Découvrez les différents types d'équilibrage de charge cloud disponibles pour GKE.
- Découvrez les fonctionnalités proposées par Anthos Service Mesh.
- Découvrez comment déployer Ingress sur plusieurs clusters GKE pour l'équilibrage de charge multirégional.
- Pour découvrir d'autres architectures de référence, schémas et bonnes pratiques, consultez le Centre d'architecture cloud.