Configurer des services en périphérie du réseau avec des groupes de points de terminaison du réseau de connectivité hybride

Google propose divers services de périphérie de réseau qui peuvent améliorer les fonctionnalités et la sécurité des services basés en dehors de Google Cloud (services sur site et multicloud), par exemple dans un centre de données sur site. ou dans un autre cloud public.

Ces services de périphérie de réseau vous permettent d'effectuer les opérations suivantes :

  • Accepter et acheminer le trafic client externe à l'échelle mondiale avec une adresse IP virtuelle Anycast unique

  • Réduire la charge du serveur en interrompant le trafic TLS en périphérie avec un équilibreur de charge d'application externe et des certificats SSL gérés par Google.

  • Activez les règles de pare-feu d'application Web (WAF, Web Application Firewall) préconfigurées, et appliquez les listes d'autorisation et les listes de blocage au trafic entrant avec Google Cloud Armor.

  • Contrôler l'accès des utilisateurs à vos applications et ressources avec Identity-Aware Proxy.

  • Optimiser la diffusion de contenu et la latence côté utilisateur avec Cloud CDN

Exemple de services de périphérie de réseau
Exemple de services de périphérie du réseau (cliquez pour agrandir)

Pour bénéficier de ces avantages sur vos services privés, sur site ou multicloud, vous devez déployer un équilibreur de charge d'application externe afin de recevoir du trafic provenant de l'Internet public. L'équilibreur de charge d'application externe transfère le trafic vers un proxy intermédiaire configuré par Cloud Service Mesh. Ce proxy intermédiaire achemine le trafic vers votre environnement sur site ou autre que Google Cloud à l'aide de Cloud VPN ou de Cloud Interconnect.

Ce tutoriel présente un exemple de bout en bout qui utilise Google Cloud Armor en périphérie de Google pour autoriser de manière sélective les clients à accéder de manière privée à un service sur site. Les clients sont autorisés à accéder à l'application en fonction de leur adresse IP.

Effectuez les tâches suivantes :

  1. Déployer Envoy en tant que proxy intermédiaire dans un groupe d'instances géré Cet Envoy est automatiquement connecté à Cloud Service Mesh.
  2. Créer une instance de machine virtuelle (VM) privée sur site simulée En réalité, vous possédez probablement déjà une VM sur site.
  3. Configurer Cloud Service Mesh pour acheminer toutes les requêtes qui atteignent le milieu vers la VM simulée sur site.
  4. Créez un équilibreur de charge d'application externe pour recevoir le trafic provenant du réseau Internet public et le transférer vers le proxy intermédiaire.
  5. Associez une stratégie de sécurité Google Cloud Armor à l'équilibreur de charge d'application externe.

Une fois ces tâches terminées, vous pouvez éventuellement explorer d'autres services périphériques et des fonctionnalités avancées de gestion du trafic.

Prérequis

Avant de configurer votre proxy intermédiaire, effectuez les tâches suivantes :

  • Consultez la page Préparer la configuration de Cloud Service Mesh avec Envoy et effectuez toutes les tâches préalables, y compris accorder les autorisations et les rôles requis et activer l'API Cloud Service Mesh.

  • Vérifiez que vos points de terminaison privés sur site sont accessibles depuis votre réseau de cloud privé virtuel (VPC) Google Cloud via Cloud VPN ou Cloud Interconnect. L'exemple utilisé dans ce tutoriel achemine uniquement le trafic vers un point de terminaison dans Google Cloud. Vous n'avez donc pas besoin de configurer une connectivité hybride pour continuer. Dans un scénario de déploiement réel, la configuration de la connectivité hybride devrait être nécessaire.

  • Assurez-vous que les plages CIDR de votre sous-réseau VPC n'entrent pas en conflit avec vos plages CIDR distantes. Lorsque les adresses IP se chevauchent, les routes de sous-réseau sont prioritaires sur la connectivité à distance.

  • Pour cette démonstration, obtenez les autorisations nécessaires pour créer et mettre à jour des règles de sécurité Google Cloud Armor. Les autorisations peuvent varier si vous souhaitez utiliser un service différent, tel que Cloud CDN.

Déployer le proxy intermédiaire sur les VM Compute Engine

Cette section décrit comment déployer Envoy en tant que proxy intermédiaire sur Compute Engine pour recevoir le trafic de l'équilibreur de charge externe et le transférer vers votre destination distante.

Créer le modèle d'instance pour le proxy intermédiaire

Un modèle d'instance spécifie la configuration des VM dans un groupe d'instances géré (MIG).

  1. Utilisez le modèle suivant pour créer des instances de VM avec un proxy Envoy connecté à Cloud Service Mesh:

    gcloud compute instance-templates create td-middle-proxy \
    --service-proxy=enabled \
    --tags=allow-hc

  2. Pour personnaliser votre déploiement Envoy, par exemple en spécifiant le nom du réseau, en définissant un chemin d'accès au journal ou en activant le traçage, consultez le guide des options de déploiement automatisé d'Envoy.

Créer le MIG du proxy intermédiaire

  1. Créez le MIG à partir du modèle. Dans cet exemple, vous pouvez conserver la taille du groupe d'instances correspondant à 1 pour déployer une seule instance. Pour l'utilisation en production, activez l'autoscaling, par exemple basé sur l'utilisation du processeur, afin d'éviter de créer un goulot d'étranglement si votre proxy intermédiaire a besoin de gérer une grande quantité de trafic.

    gcloud compute instance-groups managed create td-middle-proxy-us-central1-a \
    --zone=us-central1-a \
    --template=td-middle-proxy \
    --size=1

  2. Pour les configurations et la vérification ultérieures, identifiez et stockez l'adresse IP interne de l'instance dans MIDDLE_PROXY_IP :

    MIDDLE_PROXY_IP=$(gcloud compute instances list \
    --filter="name~'td-middle-proxy-us-central1-a-.*'" \
    --zones=us-central1-a \
    --format="value(networkInterfaces.networkIP)")

Dans cet exemple, nous créons le MIG contenant les instances de VM exécutant Envoy dans us-central1-a. Plus loin dans ce tutoriel, vous créerez un équilibreur de charge externe pour gérer le trafic Internet public provenant de vos clients.

Étant donné que l'équilibreur de charge externe peut acheminer automatiquement le trafic vers la région la plus proche de vos clients et vers le groupe d'instances géré de cette région, vous pouvez envisager de créer plusieurs MIG. Pour obtenir la liste complète des régions et des zones disponibles dans Google Cloud, consultez la page Régions et zones.

Déployer le service sur site simulé

Cette section décrit le déploiement d'un groupe de points de terminaison du réseau de connectivité hybride (NEG). Dans un déploiement en production, ce NEG contient un point de terminaison (IP:port) qui renvoie vers votre serveur sur site. Dans cet exemple, vous créez une VM Compute Engine accessible sur un IP:port. Cette VM agit en tant que serveur sur site simulé.

Créer la VM sur site de simulation

  1. Déployez une seule instance de VM pour simuler un serveur privé sur site.

    gcloud compute instances create on-prem-vm \
    --zone=us-central1-a \
    --metadata startup-script='#! /bin/bash
## Installs apache and a custom homepage
sudo su -
apt-get update
apt-get install -y apache2
cat <<EOF > /var/www/html/index.html
<html><body><h1>Hello world from on-premises!</h1></body></html>
EOF'

  2. Identifiez et stockez son adresse IP interne pour des configurations et des vérifications futures. Le serveur de cette VM écoute les requêtes entrantes sur le port 80 :

    ON_PREM_IP=$(gcloud compute instances describe on-prem-vm \
    --zone=us-central1-a \
    --format="value(networkInterfaces.networkIP)" | sed "s/['\[\]]*//g")

Créer le groupe de points de terminaison du réseau

Créez le NEG pour cette configuration de démonstration en spécifiant le type de point de terminaison du réseau non-gcp-private-ip-port. Ajoutez l'adresse IP et le port de votre VM sur site simulée comme point de terminaison à ce NEG. À la suite de l'étape précédente, l'adresse IP est stockée dans la variable d'environnement ON_PREM_IP.

  1. Créez le NEG :

    gcloud compute network-endpoint-groups create td-on-prem-neg \
    --network-endpoint-type=non-gcp-private-ip-port \
    --zone=us-central1-a

  2. Ajoutez IP:port à votre nouveau NEG :

    gcloud compute network-endpoint-groups update td-on-prem-neg \
    --zone=us-central1-a \
    --add-endpoint="ip=$ON_PREM_IP,port=80"

Configurer Cloud Service Mesh avec les composants Cloud Load Balancing

Cette section explique comment configurer Cloud Service Mesh et permettre à votre proxy intermédiaire de transférer le trafic vers votre service privé sur site. Vous configurez les composants suivants :

  • Une vérification de l'état Cette vérification de l'état se comporte légèrement différemment des vérifications d'état configurées pour d'autres types de NEG.

  • Un service de backend Pour en savoir plus, consultez la page Comprendre les services de backend.

  • Une carte des règles de routage. Cela inclut la création d'une règle de transfert, d'un proxy cible et d'un mappage d'URL. Pour plus d'informations, consultez la page sur les cartes des règles de routage.

Créer la vérification de l'état

Les vérifications de l'état vérifient que vos points de terminaison sont opérationnels et qu'ils peuvent recevoir des requêtes. La vérification de l'état de ce type de NEG repose sur le mécanisme de vérification de l'état distribué de Envoy.

D'autres types de NEG utilisent le système de vérification d'état centralisé de Google Cloud :

gcloud compute health-checks create http td-on-prem-health-check

Créez le service de backend :

  1. Créer un service de backend avec l'équilibrage de charge INTERNAL_SELF_MANAGED à utiliser avec Cloud Service Mesh. Lorsque vous créez ce service de backend, spécifiez la vérification d'état que vous avez créée précédemment :

    gcloud compute backend-services create td-on-prem-backend-service \
    --global \
    --load-balancing-scheme=INTERNAL_SELF_MANAGED \
    --health-checks=td-on-prem-health-check

  2. Ajoutez le NEG que vous avez créé précédemment en tant que backend de ce service de backend.

    gcloud compute backend-services add-backend td-on-prem-backend-service \
    --global \
    --network-endpoint-group=td-on-prem-neg \
    --network-endpoint-group-zone=us-central1-a \
    --balancing-mode=RATE \
    --max-rate-per-endpoint=5

Créer la carte des règles de routage

La carte des règles de routage définit la manière dont Cloud Service Mesh achemine le trafic vers votre un service de backend personnalisé.

  1. Créez un mappage d'URL qui utilise le service de backend défini ci-dessus.

    gcloud compute url-maps create td-hybrid-url-map \
    --default-service=td-on-prem-backend-service

  2. Créez un fichier nommé target_proxy.yaml avec le contenu suivant :

    name: td-hybrid-proxy
proxyBind: true
urlMap: global/urlMaps/td-hybrid-url-map

  3. Utilisez la commande import pour créer le proxy HTTP cible (pour en savoir plus pour en savoir plus, consultez Proxys cibles pour Cloud Service Mesh):

    gcloud compute target-http-proxies import td-hybrid-proxy \
    --source=target_proxy.yaml

  4. Créez une règle de transfert qui fait référence à ce proxy HTTP cible. Définissez l'adresse IP de la règle de transfert sur 0.0.0.0. La définition de l'adresse IP de la règle sur 0.0.0.0 achemine le trafic en fonction du port entrant, du nom d'hôte HTTP et des informations de chemin configurées dans le mappage d'URL. L'adresse IP spécifiée dans la requête HTTP est ignorée.

    gcloud compute forwarding-rules create td-hybrid-forwarding-rule \
    --global \
    --load-balancing-scheme=INTERNAL_SELF_MANAGED \
    --address=0.0.0.0 \
    --target-http-proxy=td-hybrid-proxy \
    --ports=8080 \
    --network=default

Vérifier que le proxy intermédiaire peut acheminer les requêtes vers le service sur site simulé

Cloud Service Mesh est maintenant configuré pour acheminer le trafic via la couche centrale à votre service privé sur site simulé. Vous pouvez vérifier cette configuration en créant une VM cliente de test, en vous connectant à cette VM et en envoyant une requête au proxy intermédiaire qui exécute Envoy. Après avoir vérifié la configuration, supprimez la VM cliente de test.

  1. Commencez par obtenir l'adresse IP du proxy intermédiaire. Vous n'avez besoin que de ces informations pour l'étape de validation :

    gcloud compute instances list

  2. Notez l'adresse IP de l'instance du groupe d'instances géré td-middle-proxy-us-central1-a.

  3. Créez une instance de client de test :

    gcloud compute instances create test-client \
    --zone=us-central1-a

  4. Utilisez ssh pour vous connecter au client de test:

    gcloud compute ssh test-client
    --zone=us-central1-a

  5. Envoyez une requête à la VM de proxy intermédiaire en remplaçant l'adresse IP que vous avez obtenue précédemment pour MIDDLE_PROXY_IP :

    curl $MIDDLE_PROXY_IP:8080

    Vous devriez obtenir le résultat suivant :

    Hello world from on-premises!

  6. Quittez la VM cliente de test. Après avoir quitté la VM, vous pouvez la supprimer :

    gcloud compute instances delete test-client \
    --zone=us-central1-a

Déployer l'équilibreur de charge d'application externe

Dans cette section, vous allez déployer un équilibreur de charge d'application externe qui envoie le trafic entrant vers le proxy intermédiaire. Il s'agit d'une configuration standard de l'équilibreur de charge d'application externe.

Réserver une adresse IP externe

Créer une adresse IP externe statique globale (external-lb-vip) vers laquelle les clients externes envoient le trafic Vous récupérerez cette adresse IP externe lors de l'étape de validation plus loin dans ce tutoriel.

gcloud compute addresses create external-lb-vip \
    --ip-version=IPV4 \
    --global

Configurer l'équilibreur de charge HTTP externe

Configurez l'équilibreur de charge externe pour acheminer le trafic Internet vers votre proxy intermédiaire déjà configuré.

  1. Créez une vérification d'état permettant de déterminer si le MIG qui exécute le proxy intermédiaire est opérationnel et peut recevoir du trafic :

    gcloud compute health-checks create tcp tcp-basic-check \
    --port=8080

  2. Créez une règle de pare-feu pour autoriser la vérification de l'état. Utilisez à nouveau le tag allow-hc pour appliquer la règle de pare-feu aux VM de proxy intermédiaire :

    gcloud compute firewall-rules create fw-allow-health-checks \
    --network=default \
    --action=ALLOW \
    --direction=INGRESS \
    --source-ranges=35.191.0.0/16,130.211.0.0/22 \
    --target-tags=allow-hc \
    --rules=tcp

  3. Créez un service de backend :

    gcloud compute backend-services create td-middle-proxy-backend-service \
    --protocol=HTTP \
    --health-checks=tcp-basic-check \
    --global

  4. Ajoutez le MIG du proxy intermédiaire en tant que backend à ce service de backend :

    gcloud compute backend-services add-backend td-middle-proxy-backend-service \
    --instance-group=td-middle-proxy-us-central1-a \
    --instance-group-zone=us-central1-a \
    --global

  5. Créez un mappage d'URL pour acheminer les requêtes entrantes vers le proxy intermédiaire en tant que service de backend par défaut.

    gcloud compute url-maps create lb-map-http \
    --default-service=td-middle-proxy-backend-service

  6. Créez un proxy HTTP cible de sorte que les requêtes adressées à l'adresse IP virtuelle (VIP) de la règle de transfert de l'équilibreur de charge externe soient traitées en fonction du mappage d'URL :

    gcloud compute target-http-proxies create http-lb-proxy \
    --url-map=lb-map-http

  7. Créez une règle de transfert globale pour acheminer les requêtes entrantes vers le proxy HTTP cible.

    gcloud compute forwarding-rules create http-forwarding-rule \
    --address=external-lb-vip\
    --global \
    --load-balancing-scheme=EXTERNAL \
    --target-http-proxy=http-lb-proxy \
    --ports=80

Définir le port nommé du MIG

Définissez un port nommé pour le groupe d'instances pour permettre à votre proxy intermédiaire de recevoir le trafic HTTP de l'équilibreur de charge externe.

gcloud compute instance-groups managed set-named-ports td-middle-proxy-us-central1-a \
    --named-ports=http:8080 \
    --zone=us-central1-a

Vérifier la configuration de l'équilibreur de charge d'application externe

Au cours de cette étape, vous allez vérifier que l'équilibreur de charge externe est correctement configuré.

  1. Vous devriez pouvoir envoyer une requête à l'adresse IP virtuelle de l'équilibreur de charge et obtenir une réponse de la VM virtuelle sur site simulée.

    PUBLIC_VIP=gcloud compute addresses describe external-lb-vip \
    --format="get(address)" \
    --global

  2. Envoyez une requête curl à l'adresse IP externe (PUBLIC_VIP) et vérifiez que vous recevez le message Hello world:

    curl $PUBLIC_VIP

    Le résultat suivant s'affiche :

    Hello world from on-premises!

Activer Google Cloud Armor

Configurez les règles de sécurité Google Cloud Armor pour n'autoriser l'accès à votre service qu'à partir de CLIENT_IP_RANGE, qui doit inclure l'adresse IP externe de l'appareil client avec lequel vous souhaitez effectuer des tests, par exemple, "192.0.2.0/24".

Ces règles sont appliquées au service de backend de l'équilibreur de charge externe (dans cet exemple, td-hybrid-backend-service pointant vers le proxy intermédiaire). Pour en savoir plus sur les autorisations requises pour définir ces règles, consultez la section Configurer les règles de sécurité Google Cloud Armor.

  1. Créez la stratégie de sécurité de Google Cloud Armor.

    gcloud compute security-policies create external-clients-policy \
    --description="policy for external clients"

  2. Mettez à jour la règle par défaut de la règle de sécurité pour refuser tout le trafic.

    gcloud compute security-policies rules update 2147483647 \
    --security-policy=external-clients-policy \
    --action="deny-404"

  3. Ajoutez une règle de priorité plus élevée pour autoriser le trafic provenant d'une plage d'adresses IP spécifique.

    gcloud compute security-policies rules create 1000 \
    --security-policy=external-clients-policy \
    --description="allow traffic from CLIENT_IP_RANGE" \
    --src-ip-ranges="CLIENT_IP_RANGE" \
    --action="allow"

  4. Associez les règles de sécurité Google Cloud Armor à votre service de backend.

    gcloud compute backend-services update td-middle-proxy-backend-service \
    --security-policy=external-clients-policy

Validation finale

  1. Envoyez une requête curl à l'adresse IP virtuelle publique de l'équilibreur de charge d'application externe. Si l'adresse IP de votre appareil client est comprise dans la CLIENT_IP_RANGE autorisée spécifiée précédemment, vous devriez recevoir la réponse attendue.

    curl $PUBLIC_VIP

    Le résultat suivant s'affiche :

    Hello world from on-premises!

  2. Envoyez la même requête curl à partir d'un autre appareil client dont l'adresse IP ne fait pas partie de CLIENT_IP_RANGE, ou mettez simplement à jour votre règle de sécurité pour ne plus inclure votre adresse IP client. Vous devriez maintenant recevoir une erreur 404 Not Found.

Dépannage

Les instructions suivantes décrivent comment résoudre les problèmes de configuration.

Mon service sur site n'est pas accessible via l'adresse IP de l'équilibreur de charge d'application externe global

Si votre service sur site est déjà accessible sur les VM Google Cloud sur lesquelles les Envoys s'exécutent, procédez comme suit pour résoudre les problèmes de configuration :

  1. Assurez-vous que le groupe d'instances géré Google Cloud Envoy est signalé comme étant opérationnel. Dans Google Cloud Console, accédez à Services réseau > Équilibrage de charge, puis cliquez sur url-map lb-map-http pour afficher les détails. Vous devriez voir 1/1 de l'instance dans td-middle-proxy-us-central1-a comme étant opérationnelle.

  2. Si ce n'est pas le cas, vérifiez si une règle de pare-feu a été configurée pour autoriser trafic entrant de vérification de l'état vers les VM Google Cloud en cours d'exécution Envoy:

    gcloud compute firewall-rules describe fw-allow-health-check

    Vous devriez obtenir le résultat suivant :

    allowed:
‑ IPProtocol: tcp
...
direction: INGRESS
disabled: false
...
...
sourceRanges:
‑ 130.211.0.0/22
‑ 35.191.0.0/16
targetTags:
‑ allow-hc

Étape suivante