Configurer un équilibreur de charge réseau passthrough interne avec des backends de groupes d'instances de VM pour plusieurs protocoles

Console

Pour assurer la compatibilité avec le trafic IPv4 et IPv6, procédez comme suit:

1. Dans Google Cloud Console, accédez à la page Réseaux VPC.

   Accéder aux réseaux VPC

2. Cliquez sur Créer un réseau VPC.

3. Dans le champ Nom, saisissez lb-network.

4. Si vous souhaitez configurer des plages d'adresses IPv6 internes sur les sous-réseaux de ce réseau, procédez comme suit :

   1. Dans le champ Plage IPv6 interne ULA du réseau VPC, sélectionnez Activée.
   2. Dans le champ Allouer une plage IPv6 interne, sélectionnez Automatiquement ou Manuellement.

5. Dans le champ Mode de création de sous-réseau, sélectionnez Personnalisé.

6. Dans la section Nouveau sous-réseau, spécifiez les paramètres de configuration de sous-réseau suivants :

   1. Dans le champ Nom, saisissez lb-subnet.
   2. Pour Région, sélectionnez us-west1.
   3. Pour créer un sous-réseau à double pile, sélectionnez IPv4 et IPv6 (double pile) dans le champ Type de pile d'adresses IP.
   4. Dans Plage IPv4, saisissez 10.1.2.0/24.
   5. Dans le champ Type d'accès IPv6, sélectionnez Interne.

7. Cliquez sur OK.

8. Cliquez sur Créer.

Pour assurer la compatibilité avec le trafic IPv4, procédez comme suit :

1. Dans Google Cloud Console, accédez à la page Réseaux VPC.

   Accéder aux réseaux VPC

2. Cliquez sur Créer un réseau VPC.

3. Dans le champ Nom, saisissez lb-network.

4. Dans la section Sous-réseaux :

   • Définissez Mode de création du sous-réseau sur Personnalisé.
   • Dans la section Nouveau sous-réseau, saisissez les informations suivantes :
     • Nom : lb-subnet
     • Région : us-west1
     • Type de pile IP : IPv4 (pile unique)
     • Plage d'adresses IP : 10.1.2.0/24
   • Cliquez sur OK.

5. Cliquez sur Créer.

gcloud

Pour le trafic IPv4 et IPv6, utilisez les commandes suivantes :

1. Pour créer un réseau VPC en mode personnalisé, exécutez la commande gcloud compute networks create.

   Pour configurer des plages IPv6 internes sur n'importe quel sous-réseau de ce réseau, utilisez l'option --enable-ula-internal-ipv6. Cette option attribue un préfixe ULA /48 compris dans la plage fd20::/20 utilisée par Google Cloud pour les plages de sous-réseaux IPv6 internes.

   gcloud compute networks create lb-network \
    --subnet-mode=custom \
    --enable-ula-internal-ipv6
   

2. Au sein de lb-network, créez un sous-réseau pour les backends dans la région us-west1.

   Pour créer les sous-réseaux, exécutez la commande gcloud compute networks subnets create :

   gcloud compute networks subnets create lb-subnet \
    --network=lb-network \
    --range=10.1.2.0/24 \
    --region=us-west1 \
    --stack-type=IPV4_IPV6 --ipv6-access-type=INTERNAL
   

Pour le trafic IPv4 uniquement, utilisez les commandes suivantes :

1. Pour créer un réseau VPC personnalisé, utilisez la gcloud compute networks createcommande :

   gcloud compute networks create lb-network --subnet-mode=custom
   

2. Pour créer le sous-réseau des backends dans la région us-west1 du réseau lb-network, utilisez la commande gcloud compute networks subnets create.

   gcloud compute networks subnets create lb-subnet \
       --network=lb-network \
       --range=10.1.2.0/24 \
       --region=us-west1
   

API

Pour le trafic IPv4 et IPv6, utilisez les commandes suivantes :

1. Créez un réseau VPC en mode personnalisé. Envoyez une requête POST à la méthode networks.insert.

   Pour configurer les plages IPv6 internes sur n'importe quel sous-réseau de ce réseau, définissez enableUlaInternalIpv6 sur true. Cette option attribue une plage /48 comprise dans la plage fd20::/20 utilisée par Google pour les plages de sous-réseaux IPv6 internes.

   POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks
   {
     "autoCreateSubnetworks": false,
     "name": "lb-network",
     "mtu": MTU,
     "enableUlaInternalIpv6": true,
   }
   

   Remplacez les éléments suivants :

   • PROJECT_ID : ID du projet où le réseau VPC a été créé.
   • MTU : unité de transmission maximale du réseau. La MTU peut être de 1460 (par défaut) ou de 1500. Consultez la page Présentation de l'unité de transmission maximale avant de définir la MTU sur 1500.

2. Envoyez une requête POST à la méthode subnetworks.insert.

   POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION/subnetworks
   {
   "ipCidrRange": "10.1.2.0/24",
   "network": "lb-network",
   "name": "lb-subnet"
   "stackType": IPV4_IPV6,
   "ipv6AccessType": Internal
   }
   

Pour le trafic IPv4 uniquement, suivez les étapes suivantes :

1. Envoyez une requête POST à la méthode networks.insert. Remplacez PROJECT_ID par l'ID de votre projet Google Cloud.

   POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks
   {
   "name": "lb-network",
   "autoCreateSubnetworks": false
   }
   

2. Envoyez deux requêtes POST à la méthode subnetworks.insert.

   POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks
   {
   "name": "lb-subnet",
   "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
   "ipCidrRange": "10.1.2.0/24",
   "privateIpGoogleAccess": false
   }
   

Console

1. Dans la console Google Cloud, accédez à la page Règles d'administration.

   Accéder à la page "Stratégies de pare-feu"

2. Pour autoriser le trafic TCP, UDP et ICMP IPv4 à atteindre le groupe d'instances backend ig-a, procédez comme suit :

   • Cliquez sur Créer une règle de pare-feu.
   • Nom : fw-allow-lb-access
   • Réseau : lb-network
   • Priorité : 1000
   • Sens du trafic : entrée
   • Action en cas de correspondance : autoriser
   • Cibles : toutes les instances du réseau
   • Filtre source : plages IPv4
   • Plages IPv4 sources : 10.1.2.0/24
   • Protocoles et ports : sélectionnez Protocoles et ports spécifiés.
     • Sélectionnez TCP et saisissez ALL.
     • Sélectionnez UDP.
     • Sélectionnez Autre et saisissez ICMP.

3. Cliquez sur Créer.

4. Pour autoriser les connexions SSH entrantes :

   • Cliquez sur Créer une règle de pare-feu.
   • Nom : fw-allow-ssh
   • Réseau : lb-network
   • Priorité : 1000
   • Sens du trafic : entrée
   • Action en cas de correspondance : autoriser
   • Cibles : tags cibles spécifiés
   • Tags cibles : allow-ssh
   • Filtre source : plages IPv4
   • Plages IPv4 sources : 0.0.0.0/0
   • Protocoles et ports : sélectionnez Protocoles et ports spécifiés, puis saisissez tcp:22.

5. Cliquez sur Créer.

6. Pour autoriser le trafic TCP, UDP et ICMP IPv6 à atteindre le groupe d'instances backend ig-a, procédez comme suit :

   • Cliquez sur Créer une règle de pare-feu.
   • Nom : fw-allow-lb-access-ipv6
   • Réseau : lb-network
   • Priorité : 1000
   • Sens du trafic : entrée
   • Action en cas de correspondance : autoriser
   • Cibles : toutes les instances du réseau
   • Filtre source : Plages IPv6
   • Plages IPv6 sources : adresse IPV6_ADDRESS attribuée dans lb-subnet
   • Protocoles et ports : sélectionnez Protocoles et ports spécifiés.
     • Sélectionnez TCP et saisissez 0-65535.
     • Sélectionnez UDP.
     • SélectionnerAutre et pour le protocole ICMPv6, saisissez 58.

7. Cliquez sur Créer.

8. Pour autoriser les vérifications d'état IPv6 de Google Cloud, procédez comme suit :

   • Cliquez sur Créer une règle de pare-feu.
   • Nom : fw-allow-health-check-ipv6
   • Réseau : lb-network
   • Priorité : 1000
   • Sens du trafic : entrée
   • Action en cas de correspondance : autoriser
   • Cibles : tags cibles spécifiés
   • Tags cibles : allow-health-check-ipv6
   • Filtre source : Plages IPv6
   • Plages IPv6 sources : 2600:2d00:1:b029::/64
   • Protocoles et ports : tout autoriser

9. Cliquez sur Créer.

10. Pour autoriser les vérifications d'état IPv4 de Google Cloud, procédez comme suit :

    • Cliquez sur Créer une règle de pare-feu.
    • Nom : fw-allow-health-check
    • Réseau : lb-network
    • Priorité : 1000
    • Sens du trafic : entrée
    • Action en cas de correspondance : autoriser
    • Cibles : tags cibles spécifiés
    • Tags cibles : allow-health-check
    • Filtre source : plages IPv4
    • Plages IPv4 sources : 130.211.0.0/22 et 35.191.0.0/16
    • Protocoles et ports : tout autoriser

11. Cliquez sur Create (Créer).

gcloud

1. Pour permettre au trafic TCP IPv4 d'atteindre le groupe d'instances backend ig-a, créez la règle suivante :

   gcloud compute firewall-rules create fw-allow-lb-access \
       --network=lb-network \
       --action=allow \
       --direction=ingress \
       --source-ranges=10.1.2.0/24 \
       --rules=tcp,udp,icmp
   

2. Créez une règle de pare-feu fw-allow-ssh pour autoriser la connectivité SSH aux VM en utilisant le tag réseau allow-ssh. Lorsque vous omettez source-ranges, Google Cloud interprète la règle comme désignant n'importe quelle source.

   gcloud compute firewall-rules create fw-allow-ssh \
       --network=lb-network \
       --action=allow \
       --direction=ingress \
       --target-tags=allow-ssh \
       --rules=tcp:22
   

3. Pour permettre au trafic IPv6 d'atteindre le groupe d'instances backend ig-a, créez la règle suivante :

   gcloud compute firewall-rules create fw-allow-lb-access-ipv6 \
       --network=lb-network \
       --action=allow \
       --direction=ingress \
       --source-ranges=IPV6_ADDRESS \
       --rules=all
   

   Remplacez IPV6_ADDRESS par l'adresse IPv6 attribuée dans lb-subnet.

4. Créez la règle de pare-feu fw-allow-health-check pour autoriser les vérifications d'état Google Cloud.

   gcloud compute firewall-rules create fw-allow-health-check \
       --network=lb-network \
       --action=allow \
       --direction=ingress \
       --target-tags=allow-health-check \
       --source-ranges=130.211.0.0/22,35.191.0.0/16 \
       --rules=tcp,udp,icmp
   

5. Créez la règle fw-allow-health-check-ipv6 pour autoriser les vérifications d'état IPv6 Google Cloud.

   gcloud compute firewall-rules create fw-allow-health-check-ipv6 \
      --network=lb-network \
      --action=allow \
      --direction=ingress \
      --target-tags=allow-health-check-ipv6 \
      --source-ranges=2600:2d00:1:b029::/64 \
      --rules=tcp,udp,icmp
   

API

1. Pour créer la règle de pare-feu fw-allow-lb-access, envoyez une requête POST à la méthode firewalls.insert. Remplacez PROJECT_ID par l'ID de votre projet Google Cloud.

   POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls
   {
   "name": "fw-allow-lb-access",
   "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
   "priority": 1000,
   "sourceRanges": [
     "10.1.2.0/24"
   ],
   "allPorts": true,
   "allowed": [
     {
       "IPProtocol": "tcp"
     },
     {
       "IPProtocol": "udp"
     },
     {
       "IPProtocol": "icmp"
     }
   ],
   "direction": "INGRESS",
   "logConfig": {
     "enable": false
   },
   "disabled": false
   }
   

2. Créez la règle de pare-feu fw-allow-lb-access-ipv6 en envoyant une requête POST à la méthode firewalls.insert.

   POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls
   {
    "name": "fw-allow-lb-access-ipv6",
    "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
    "priority": 1000,
    "sourceRanges": [
      "IPV6_ADDRESS"
    ],
    "allPorts": true,
    "allowed": [
      {
         "IPProtocol": "tcp"
       },
       {
         "IPProtocol": "udp"
       },
       {
         "IPProtocol": "58"
       }
    ],
    "direction": "INGRESS",
    "logConfig": {
       "enable": false
    },
    "disabled": false
   }
   

   Remplacez IPV6_ADDRESS par l'adresse IPv6 attribuée dans lb-subnet.

3. Pour créer la règle de pare-feu fw-allow-ssh, envoyez une requête POST à la méthode firewalls.insert :

   POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls
   {
   "name": "fw-allow-ssh",
        "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
   "priority": 1000,
   "sourceRanges": [
     "0.0.0.0/0"
   ],
   "targetTags": [
     "allow-ssh"
   ],
   "allowed": [
    {
      "IPProtocol": "tcp",
      "ports": [
        "22"
      ]
    }
   ],
   "direction": "INGRESS",
   "logConfig": {
    "enable": false
   },
   "disabled": false
   }
   

4. Pour créer la règle de pare-feu fw-allow-health-check, envoyez une requête POST à la méthode firewalls.insert.

   POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls
   {
   "name": "fw-allow-health-check",
   "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
   "priority": 1000,
   "sourceRanges": [
     "130.211.0.0/22",
     "35.191.0.0/16"
   ],
   "targetTags": [
     "allow-health-check"
   ],
   "allowed": [
     {
       "IPProtocol": "tcp"
     },
     {
       "IPProtocol": "udp"
     },
     {
       "IPProtocol": "icmp"
     }
   ],
   "direction": "INGRESS",
   "logConfig": {
     "enable": false
   },
   "disabled": false
   }
   

5. Créez la règle de pare-feu fw-allow-health-check-ipv6 en envoyant une requête POST à la méthode firewalls.insert.

   POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls
   {
   "name": "fw-allow-health-check-ipv6",
   "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
   "priority": 1000,
   "sourceRanges": [
     "2600:2d00:1:b029::/64"
   ],
   "targetTags": [
     "allow-health-check-ipv6"
   ],
   "allowed": [
     {
       "IPProtocol": "tcp"
     },
     {
       "IPProtocol": "udp"
     }
   ],
   "direction": "INGRESS",
   "logConfig": {
     "enable": false
   },
   "disabled": false
   }
   

Console

Pour assurer la compatibilité avec le trafic IPv4 et IPv6, procédez comme suit:

1. Créez un modèle d'instance. Dans Google Cloud Console, accédez à la page Modèles d'instances.

   Accéder à la page Modèles d'instances

   1. Cliquez sur Create instance template (Créer un modèle d'instance).
   2. Dans le champ Nom, saisissez vm-a1.
   3. Assurez-vous que le disque de démarrage est défini sur une image Debian, telle que Debian GNU/Linux 10 (Buster). Ces instructions utilisent des commandes uniquement disponibles dans Debian, comme apt-get.
   4. Cliquez sur Mise en réseau, disques, sécurité, gestion, location unique.

   5. Cliquez sur Gestion et copiez le script suivant dans le champ Script de démarrage. Le script de démarrage configure également le serveur Apache pour qu'il écoute sur le port 8080 au lieu du port 80.

      #! /bin/bash
      apt-get update
      apt-get install apache2 -y
      a2ensite default-ssl
      a2enmod ssl
      vm_hostname="$(curl -H "Metadata-Flavor:Google" \
      http://metadata.google.internal/computeMetadata/v1/instance/name)"
      echo "Page served from: $vm_hostname" | \
      tee /var/www/html/index.html
      sed -ire 's/^Listen 80$/Listen 8080/g' /etc/apache2/ports.conf
      systemctl restart apache2
      

   6. Cliquez sur Mise en réseau.

      1. Pour Tags réseau, ajoutez allow-ssh et allow-health-check-ipv6.
      2. Pour Interfaces réseau, cliquez sur l'interface default et configurez les champs suivants :
         • Réseau : lb-network
         • Sous-réseau : lb-subnet
         • Type de pile d'adresses IP: IPv4 et IPv6 (double pile)

   7. Cliquez sur Créer.

Pour assurer la compatibilité avec le trafic IPv4, procédez comme suit :

1. Créez un modèle d'instance. Dans Google Cloud Console, accédez à la page Modèles d'instances.

   Accéder à la page Modèles d'instances

   1. Cliquez sur Create instance template (Créer un modèle d'instance).
   2. Dans le champ Nom, saisissez vm-a1.
   3. Assurez-vous que le disque de démarrage est défini sur une image Debian, telle que Debian GNU/Linux 10 (Buster). Ces instructions utilisent des commandes uniquement disponibles dans Debian, comme apt-get.
   4. Cliquez sur Mise en réseau, disques, sécurité, gestion, location unique.

   5. Cliquez sur Gestion et copiez le script suivant dans le champ Script de démarrage. Le script de démarrage configure également le serveur Apache pour qu'il écoute sur le port 8080 au lieu du port 80.

      #! /bin/bash
      apt-get update
      apt-get install apache2 -y
      a2ensite default-ssl
      a2enmod ssl
      vm_hostname="$(curl -H "Metadata-Flavor:Google" \
      http://metadata.google.internal/computeMetadata/v1/instance/name)"
      echo "Page served from: $vm_hostname" | \
      tee /var/www/html/index.html
      sed -ire 's/^Listen 80$/Listen 8080/g' /etc/apache2/ports.conf
      systemctl restart apache2
      

   6. Cliquez sur Mise en réseau.

      1. Pour Tags réseau, ajoutez allow-ssh et allow-health-check.
      2. Pour Interfaces réseau, cliquez sur l'interface default et configurez les champs suivants :
         • Réseau : lb-network
         • Sous-réseau : lb-subnet
         • Type de pile IP : IPv4 (pile unique)

   7. Cliquez sur Créer.

2. Créez un groupe d'instances géré. Accédez à la page Groupes d'instances de la console Google Cloud.

   Accéder à la page "Groupes d'instances"

   1. Cliquez sur Créer un groupe d'instances.
   2. Choisissez Nouveau groupe d'instances géré (sans état). Pour des informations plus détaillées, consultez la page Groupes d'instances gérés (MIG) sans état ou avec état.
   3. Dans le champ Nom, saisissez ig-a.
   4. Pour Emplacement, sélectionnez Zone unique.
   5. Pour la région, sélectionnez us-west1.
   6. Pour la zone, sélectionnez us-west1-a.
   7. Pour Modèle d'instance, sélectionnez vm-a1.

   8. Spécifiez le nombre d'instances que vous souhaitez créer au sein du groupe.

      Pour cet exemple, spécifiez les options suivantes sous Autoscaling :

      • Dans le champ Mode autoscaling, sélectionnez Off:do not autoscale.
      • Dans le champ Nombre maximal d'instances, saisissez 2.

   9. Cliquez sur Créer.

gcloud

Les instructions gcloud de ce guide supposent que vous utilisez Cloud Shell ou un autre environnement avec bash installé.

1. Créez un modèle d'instance de VM avec le serveur HTTP à l'aide de la commande gcloud compute instance-templates create.

   Le script de démarrage configure également le serveur Apache pour qu'il écoute sur le port 8080 au lieu du port 80.

   Pour gérer le trafic IPv4 et IPv6, utilisez la commande suivante.

   gcloud compute instance-templates create vm-a1 \
       --region=us-west1 \
       --network=lb-network \
       --subnet=lb-subnet \
       --ipv6-network-tier=PREMIUM \
       --stack-type=IPv4_IPv6 \
       --tags=allow-ssh \
       --image-family=debian-10 \
       --image-project=debian-cloud \
       --metadata=startup-script='#! /bin/bash
         apt-get update
         apt-get install apache2 -y
         a2ensite default-ssl
         a2enmod ssl
         vm_hostname="$(curl -H "Metadata-Flavor:Google" \
         http://metadata.google.internal/computeMetadata/v1/instance/name)"
         echo "Page served from: $vm_hostname" | \
         tee /var/www/html/index.html
         sed -ire "s/^Listen 80$/Listen 8080/g" /etc/apache2/ports.conf
         systemctl restart apache2'
   

   Si vous souhaitez gérer le trafic IPv4 uniquement, utilisez la commande suivante.

   gcloud compute instance-templates create vm-a1 \
       --region=us-west1 \
       --network=lb-network \
       --subnet=lb-subnet \
       --tags=allow-ssh \
       --image-family=debian-10 \
       --image-project=debian-cloud \
       --metadata=startup-script='#! /bin/bash
         apt-get update
         apt-get install apache2 -y
         a2ensite default-ssl
         a2enmod ssl
         vm_hostname="$(curl -H "Metadata-Flavor:Google" \
         http://metadata.google.internal/computeMetadata/v1/instance/name)"
         echo "Page served from: $vm_hostname" | \
         tee /var/www/html/index.html
         sed -ire "s/^Listen 80$/Listen 8080/g" /etc/apache2/ports.conf
         systemctl restart apache2'
   

2. Créez un groupe d'instances géré dans la zone à l'aide de la commande gcloud compute instance-groups managed create.

   gcloud compute instance-groups managed create ig-a \
       --zone us-west1-a \
       --size 2 \
       --template vm-a1
   

api

Pour gérer le trafic IPv4 et IPv6, suivez les étapes suivantes :

1. Créez une VM en envoyant des requêtes POST à la méthode instances.insert :

   POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances
   {
   "name": "vm-a1",
   "tags": {
    "items": [
      "allow-health-check-ipv6",
      "allow-ssh"
    ]
   },
   "machineType": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/machineTypes/e2-standard-2",
   "canIpForward": false,
   "networkInterfaces": [
    {
      "stackType": "IPV4_IPV6",
      "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
      "subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet",
      "accessConfigs": [
        {
          "type": "ONE_TO_ONE_NAT",
          "name": "external-nat",
          "networkTier": "PREMIUM"
        }
      ]
    }
   ],
   "disks": [
    {
      "type": "PERSISTENT",
      "boot": true,
      "mode": "READ_WRITE",
      "autoDelete": true,
      "deviceName": "vm-a1",
      "initializeParams": {
        "sourceImage": "projects/debian-cloud/global/images/DEBIAN_IMAGE_NAME",
        "diskType": "projects/PROJECT_ID/zones/ZONE/diskTypes/pd-standard",
        "diskSizeGb": "10"
      }
    }
   ],
   "metadata": {
    "items": [
      {
        "key": "startup-script",
        "value": "#! /bin/bash\napt-get update\napt-get install apache2 -y\na2ensite default-ssl\na2enmod ssl\nvm_hostname="$(curl -H "Metadata-Flavor:Google" \\\nhttp://metadata.google.internal/computeMetadata/v1/instance/name)"\necho "Page served from: $vm_hostname" | \\\ntee /var/www/html/index.html\nsed -ire "s/^Listen 80$/Listen 8080/g" /etc/\\napache2/ports.conf\nsystemctl restart apache2"
      }
    ]
   },
   "scheduling": {
    "preemptible": false
   },
   "deletionProtection": false
   }
   

Pour gérer le trafic IPv4, procédez comme suit :

1. Créez une VM en envoyant des requêtes POST à la méthode instances.insert :

   POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances
   {
   "name": "vm-a1",
   "tags": {
    "items": [
      "allow-health-check",
      "allow-ssh"
    ]
   },
   "machineType": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/machineTypes/e2-standard-2",
   "canIpForward": false,
   "networkInterfaces": [
    {
      "stackType": "IPV4",
      "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
      "subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet",
      "accessConfigs": [
        {
          "type": "ONE_TO_ONE_NAT",
          "name": "external-nat",
          "networkTier": "PREMIUM"
        }
      ]
    }
   ],
   "disks": [
    {
      "type": "PERSISTENT",
      "boot": true,
      "mode": "READ_WRITE",
      "autoDelete": true,
      "deviceName": "vm-a1",
      "initializeParams": {
        "sourceImage": "projects/debian-cloud/global/images/DEBIAN_IMAGE_NAME",
        "diskType": "projects/PROJECT_ID/zones/ZONE/diskTypes/pd-standard",
        "diskSizeGb": "10"
      }
    }
   ],
   "metadata": {
    "items": [
      {
        "key": "startup-script",
        "value": "#! /bin/bash\napt-get update\napt-get install apache2 -y\na2ensite default-ssl\na2enmod ssl\nvm_hostname="$(curl -H "Metadata-Flavor:Google" \\\nhttp://metadata.google.internal/computeMetadata/v1/instance/name)"\necho "Page served from: $vm_hostname" | \\\ntee /var/www/html/index.html\nsed -ire "s/^Listen 80$/Listen 8080/g" /etc/\\napache2/ports.conf\nsystemctl restart apache2"
      }
    ]
   },
   "scheduling": {
    "preemptible": false
   },
   "deletionProtection": false
   }
   

2. Créez un groupe d'instance en envoyant une requête POST à la méthode instanceGroups.insert :

   POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instanceGroups
   
   {
   "name": "ig-a",
   "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
   "subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet"
   }
   

3. Ajoutez des instances à chaque groupe d'instances en envoyant une requête POST à la méthode instanceGroups.addInstances.

   POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instanceGroups/ig-a/addInstances
   
   {
   "instances": [
   {
    "instance": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instances/vm-a1"
   }
   ]
   }
   

Console

1. Dans la console Google Cloud, accédez à la page Instances de VM.

   Accéder à la page "Instances de VM"

2. Cliquez sur Créer une instance.

3. Définissez le paramètre Nom sur vm-client-ipv6.

4. Définissez le paramètre Zone sur us-west1-a.

5. Cliquez sur Gestion, sécurité, disques, mise en réseau et location unique et apportez les modifications suivantes :

   • Cliquez sur Mise en réseau et ajoutez allow-ssh aux tags réseau.
   • Sous Interfaces réseau, cliquez sur Modifier, apportez les modifications suivantes, puis cliquez sur OK :
     • Réseau : lb-network
     • Sous-réseau : lb-subnet
     • Type de pile d'adresses IP: IPv4 et IPv6 (double pile)
     • Adresse IP interne principale : éphémère (automatique)
     • Adresse IP externe : Éphémère

6. Cliquez sur Créer.

gcloud

La VM cliente peut se trouver dans n'importe quelle zone de la même région que l'équilibreur de charge, et utiliser n'importe quel sous-réseau de cette région. Dans cet exemple, le client se situe dans la zone us-west1-a et utilise le même sous-réseau que les VM de backend.

gcloud compute instances create vm-client-ipv6 \
    --zone=us-west1-a \
    --image-family=debian-10 \
    --image-project=debian-cloud \
    --stack-type=IPV4_IPV6 \
    --tags=allow-ssh \
    --subnet=lb-subnet

api

Envoyez une requête POST à la méthode instances.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instances

{
 "name": "vm-client-ipv6",
 "tags": {
   "items": [
     "allow-ssh"
   ]
 },
 "machineType": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/machineTypes/e2-standard-2",
 "canIpForward": false,
 "networkInterfaces": [
   {
     "stackType": "IPV4_IPV6",
     "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
     "subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet",
     "accessConfigs": [
       {
         "type": "ONE_TO_ONE_NAT",
         "name": "external-nat",
         "networkTier": "PREMIUM"
       }
     ]
   }
 ],
 "disks": [
   {
     "type": "PERSISTENT",
     "boot": true,
     "mode": "READ_WRITE",
     "autoDelete": true,
     "deviceName": "vm-client",
     "initializeParams": {
       "sourceImage": "projects/debian-cloud/global/images/debian-image-name",
       "diskType": "projects/PROJECT_ID/zones/us-west1-a/diskTypes/pd-standard",
       "diskSizeGb": "10"
     }
   }
 ],
 "scheduling": {
   "preemptible": false
 },
 "deletionProtection": false
}

Console

1. Dans la console Google Cloud, accédez à la page Instances de VM.

   Accéder à la page "Instances de VM"

2. Cliquez sur Créer une instance.

3. Dans le champ Nom, saisissez vm-client.

4. Dans le champ Zone, saisissez us-west1-a.

5. Cliquez sur Options avancées.

6. Cliquez sur Mise en réseau et configurez les champs suivants :

   1. Pour Tags réseau, saisissez allow-ssh.
   2. Pour Interfaces réseau, sélectionnez l'option suivante :
      • Réseau : lb-network
      • Sous-réseau : lb-subnet

7. Cliquez sur Créer.

gcloud

La VM cliente peut se trouver dans n'importe quelle zone de la même région que l'équilibreur de charge, et utiliser n'importe quel sous-réseau de cette région. Dans cet exemple, le client se situe dans la zone us-west1-a et utilise le même sous-réseau que les VM de backend.

gcloud compute instances create vm-client \
    --zone=us-west1-a \
    --image-family=debian-10 \
    --image-project=debian-cloud \
    --tags=allow-ssh \
    --subnet=lb-subnet

API

Envoyez une requête POST à la méthode instances.insert. Remplacez PROJECT_ID par l'ID de votre projet Google Cloud.

 POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instances
 {
    "name": "vm-client",
    "tags": {
      "items": [
        "allow-ssh"
      ]
  },
    "machineType": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/machineTypes/e2-standard-2",
    "canIpForward": false,
    "networkInterfaces": [
      {
        "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
        "subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet",
        "accessConfigs": [
          {
            "type": "ONE_TO_ONE_NAT",
            "name": "external-nat",
            "networkTier": "PREMIUM"
          }
        ]
      }
    ],
    "disks": [
      {
        "type": "PERSISTENT",
        "boot": true,
        "mode": "READ_WRITE",
        "autoDelete": true,
        "deviceName": "vm-client",
        "initializeParams": {
          "sourceImage": "projects/debian-cloud/global/images/debian-image-name",
          "diskType": "projects/PROJECT_ID/zones/us-west1-a/diskTypes/pd-standard",
          "diskSizeGb": "10"
        }
      }
    ],
    "scheduling": {
      "preemptible": false
     },
    "deletionProtection": false
  }
  

gcloud

1. Créez une vérification d'état HTTP pour le port 80. Cette vérification d'état permet de vérifier l'état des backends dans le groupe d'instances ig-a.

   gcloud compute health-checks create http hc-http-80 \
       --region=us-west1 \
       --port=80
   

2. Créez le service de backend avec le protocole défini sur UNSPECIFIED :

   gcloud compute backend-services create be-ilb-l3-default \
       --load-balancing-scheme=internal \
       --protocol=UNSPECIFIED \
       --region=us-west1 \
       --health-checks=hc-http-80 \
       --health-checks-region=us-west1
   

3. Ajoutez le groupe d'instances backend au service de backend :

   gcloud compute backend-services add-backend be-ilb-l3-default \
       --region=us-west1 \
       --instance-group=ig-a \
       --instance-group-zone=us-west1-a
   

4. Pour le trafic IPv6 : créez une règle de transfert en définissant le protocole sur L3_DEFAULT pour gérer tout le trafic IPv6 compatible. Tous les ports doivent être configurés avec des règles de transfert L3_DEFAULT.

   gcloud compute forwarding-rules create fr-ilb-ipv6 \
      --region=us-west1 \
      --load-balancing-scheme=internal \
      --subnet=lb-subnet \
      --ip-protocol=L3_DEFAULT \
      --ports=ALL \
      --backend-service=be-ilb-l3-default \
      --backend-service-region=us-west1 \
      --ip-version=IPV6
   

5. Pour le trafic IPv4 : créez une règle de transfert en définissant le protocole sur L3_DEFAULT pour gérer tout le trafic IPv4 compatible. Tous les ports doivent être configurés avec des règles de transfert L3_DEFAULT. Utilisez 10.1.2.99 comme adresse IP interne.

   gcloud compute forwarding-rules create fr-ilb-l3-default \
      --region=us-west1 \
      --load-balancing-scheme=internal \
      --network=lb-network \
      --subnet=lb-subnet \
      --address=10.1.2.99 \
      --ip-protocol=L3_DEFAULT \
      --ports=ALL \
      --backend-service=be-ilb-l3-default \
      --backend-service-region=us-west1
   

API

1. Créez la vérification d'état en envoyant une requête POST à la méthode regionHealthChecks.insert. Remplacez PROJECT_ID par l'ID de votre projet Google Cloud.

   POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/regionHealthChecks
   
   {
   "name": "hc-http-80",
   "type": "HTTP",
   "httpHealthCheck": {
    "port": 80
   }
   }
   

2. Créez le service de backend régional en envoyant une requête POST à la méthode regionBackendServices.insert.

   POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices
   
   {
   "name": "be-ilb-l3-default",
   "backends": [
    {
      "group": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instanceGroups/ig-a",
      "balancingMode": "CONNECTION"
    }
   ],
   "healthChecks": [
    "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/healthChecks/hc-http-80"
   ],
   "loadBalancingScheme": "INTERNAL",
   "protocol": "UNSPECIFIED",
   "connectionDraining": {
    "drainingTimeoutSec": 0
   }
   }
   

3. Pour le trafic IPv6 : créez la règle de transfert en envoyant une requête POST à la méthode forwardingRules.insert.

   POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules
   
   {
   "name": "fr-ilb-ipv6",
   "IPProtocol": "L3_DEFAULT",
   "allPorts": true,
   "loadBalancingScheme": "INTERNAL",
   "subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet",
   "backendService": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices/be-ilb-l3-default",
   "ipVersion": "IPV6",
   "networkTier": "PREMIUM"
   }
   

4. Pour le trafic IPv4 : créez la règle de transfert en envoyant une requête POST à la méthode forwardingRules.insert:

   POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules
   
   {
   "name": "fr-ilb-l3-default",
   "IPAddress": "10.1.2.99",
   "IPProtocol": "L3_DEFAULT",
   "allPorts": true,
   "loadBalancingScheme": "INTERNAL",
   "subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet",
   "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
   "backendService": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices/be-ilb-l3-default",
   "networkTier": "PREMIUM"
   }
   

gcloud : IPv6

1. Connectez-vous à l'instance de VM cliente.

   gcloud compute ssh vm-client-ipv6 --zone=us-west1-a
   

2. Décrivez la règle de transfert IPv6 fr-ilb-ipv6. Notez l'élément IPV6_ADDRESS dans la description.

   gcloud compute forwarding-rules describe fr-ilb-ipv6 --region=us-west1
   

3. À partir de clients disposant d'une connectivité IPv6, exécutez la commande suivante. Remplacez IPV6_ADDRESS par l'adresse IPv6 éphémère dans la règle de transfert fr-ilb-ipv6.

   curl -m 10 -s http://IPV6_ADDRESS:80
   

   Par exemple, si l'adresse IPv6 attribuée est [fd20:1db0:b882:802:0:46:0:0/96]:80, la commande doit se présenter comme suit :

   curl -m 10 -s http://[fd20:1db0:b882:802:0:46:0:0]:80
   

gcloud : IPv4

1. Connectez-vous à l'instance de VM cliente.

   gcloud compute ssh vm-client --zone=us-west1-a
   

2. Décrivez la règle de transfert IPv4 fr-ilb.

   gcloud compute forwarding-rules describe fr-ilb --region=us-west1
   

3. Envoyez une requête Web à l'équilibreur de charge à l'aide de curl pour contacter son adresse IP. Répétez la requête pour que les réponses proviennent de différentes VM de backend. Le nom de la VM qui génère la réponse est affiché dans le texte de la réponse HTML selon le contenu de /var/www/html/index.html sur chaque VM de backend. Les réponses attendues ressemblent à ceci : Page served from: vm-a1.

   curl http://10.1.2.99
   

   La règle de transfert est configurée pour desservir les ports 80 et 53. Pour envoyer du trafic vers ces ports, ajoutez deux points (:) et le numéro de port après l'adresse IP, comme ceci :

   curl http://10.1.2.99:80
   

gcloud : IPv6

1. Connectez-vous à l'instance de VM cliente.

   gcloud compute ssh vm-client-ipv6 --zone=us-west1-a
   

2. Essayez de pinguer l'adresse IPv6 de l'équilibreur de charge. Remplacez IPV6_ADDRESS par l'adresse IPv6 éphémère dans la règle de transfert fr-ilb-ipv6.

   Notez que vous obtenez une réponse et que la commande ping fonctionne dans cet exemple.

   ping6 IPV6_ADDRESS
   

   Par exemple, si l'adresse IPv6 attribuée est [2001:db8:1:1:1:1:1:1/96], la commande est la suivante :

   ping6 2001:db8:1:1:1:1:1:1
   

   Le résultat ressemble à ce qui suit :

   @vm-client: ping IPV6_ADDRESS
   PING IPV6_ADDRESS (IPV6_ADDRESS) 56(84) bytes of data.
   64 bytes from IPV6_ADDRESS: icmp_seq=1 ttl=64 time=1.58 ms
   

gcloud : IPv4

1. Connectez-vous à l'instance de VM cliente.

   gcloud compute ssh vm-client --zone=us-west1-a
   

2. Essayez de pinguer l'adresse IPv4 de l'équilibreur de charge. Notez que vous obtenez une réponse et que la commande ping fonctionne dans cet exemple.

   ping 10.1.2.99
   

   Le résultat est le suivant :

   @vm-client: ping 10.1.2.99
   PING 10.1.2.99 (10.1.2.99) 56(84) bytes of data.
   64 bytes from 10.1.2.99: icmp_seq=1 ttl=64 time=1.58 ms
   64 bytes from 10.1.2.99: icmp_seq=2 ttl=64 time=0.242 ms
   64 bytes from 10.1.2.99: icmp_seq=3 ttl=64 time=0.295 ms
   

gcloud

Exécutez la commande gcloud compute addresses create :

gcloud compute addresses create internal-lb-ipv4 \
    --region us-west1 \
    --subnet lb-subnet \
    --purpose SHARED_LOADBALANCER_VIP \
    --addresses 10.1.2.99

API

Appelez la méthode addresses.insert. Remplacez PROJECT_ID par l'ID de votre projet Google Cloud.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/addresses

Le corps de la requête doit inclure le type d'adresse (addressType) avec la valeur INTERNAL, le nom de l'adresse (name) et le sous-réseau (subnetwork) auquel appartient l'adresse IP. Vous devez spécifier address en tant que 10.1.2.99.

{
  "addressType": "INTERNAL",
  "name": "internal-lb-ipv4",
  "subnetwork": "regions/us-west1/subnetworks/lb-subnet",
  "purpose": "SHARED_LOADBALANCER_VIP",
  "address": "10.1.2.99"
}

gcloud

1. Créez le service de backend pour le trafic TCP :

   gcloud compute backend-services create be-ilb \
       --load-balancing-scheme=internal \
       --protocol=tcp \
       --region=us-west1 \
       --health-checks=hc-http-80 \
       --health-checks-region=us-west1
   

2. Ajoutez le groupe d'instances backend au service de backend :

   gcloud compute backend-services add-backend be-ilb \
       --region=us-west1 \
       --instance-group=ig-a \
       --instance-group-zone=us-west1-a
   

3. Créez une règle de transfert pour le service de backend. Utilisez l'adresse IP interne réservée statique (internal-lb-ipv4) pour l'adresse IP interne.

   gcloud compute forwarding-rules create fr-ilb \
       --region=us-west1 \
       --load-balancing-scheme=internal \
       --network=lb-network \
       --subnet=lb-subnet \
       --address=internal-lb-ipv4 \
       --ip-protocol=TCP \
       --ports=80 \
       --backend-service=be-ilb \
       --backend-service-region=us-west1
   

API

1. Créez le service de backend régional en envoyant une requête POST à la méthode regionBackendServices.insert. Remplacez PROJECT_ID par l'ID de votre projet Google Cloud.

   POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices
   {
   "name": "be-ilb",
   "backends": [
    {
      "group": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instanceGroups/ig-a",
      "balancingMode": "CONNECTION"
    }
   ],
   "healthChecks": [
    "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/healthChecks/hc-http-80"
   ],
   "loadBalancingScheme": "INTERNAL",
   "protocol": "TCP",
   "connectionDraining": {
    "drainingTimeoutSec": 0
   }
   }
   

2. Create the forwarding rule by making a POST request to the forwardingRules.insert method:

   POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules
   
   {
   "name": "fr-ilb",
   "IPAddress": "internal-lb-ipv4",
   "IPProtocol": "TCP",
   "ports": [
    "80"
   ],
   "loadBalancingScheme": "INTERNAL",
   "subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet",
   "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
   "backendService": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices/be-ilb",
   "networkTier": "PREMIUM"
   }
   

gcloud

1. Créez le service de backend avec le protocole défini sur UDP :

   gcloud compute backend-services create be-ilb-udp \
       --load-balancing-scheme=internal \
       --protocol=UDP \
       --region=us-west1 \
       --health-checks=hc-http-80 \
       --health-checks-region=us-west1
   

2. Ajoutez le groupe d'instances backend au service de backend :

   gcloud compute backend-services add-backend be-ilb-udp \
       --region=us-west1 \
       --instance-group=ig-a \
       --instance-group-zone=us-west1-a
   

3. Créez une règle de transfert pour le service de backend. Utilisez l'adresse IP interne réservée statique (internal-lb-ipv4) pour l'adresse IP interne.

   gcloud compute forwarding-rules create fr-ilb-udp \
       --region=us-west1 \
       --load-balancing-scheme=internal \
       --network=lb-network \
       --subnet=lb-subnet \
       --address=internal-lb-ipv4 \
       --ip-protocol=UDP \
       --ports=53 \
       --backend-service=be-ilb-udp \
       --backend-service-region=us-west1
   

API

1. Créez le service de backend régional en envoyant une requête POST à la méthode regionBackendServices.insert. Remplacez PROJECT_ID par l'ID de votre projet Google Cloud.

   POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices
   {
   "name": "be-ilb-udp",
   "backends": [
    {
     "group": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instanceGroups/ig-a",
     "balancingMode": "CONNECTION"
    }
   ],
   "healthChecks": [
    "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/healthChecks/hc-http-80"
   ],
   "loadBalancingScheme": "INTERNAL",
   "protocol": "UDP",
   "connectionDraining": {
    "drainingTimeoutSec": 0
   }
   }
   

2. Créez la règle de transfert en envoyant une requête POST à la méthode forwardingRules.insert.

   POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules
   
   {
   "name": "fr-ilb-udp",
   "IPAddress": "internal-lb-ipv4",
   "IPProtocol": "UDP",
   "ports": [
    "53"
   ],
   "loadBalancingScheme": "INTERNAL",
   "subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet",
   "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
   "backendService": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices/be-ilb-udp",
   "networkTier": "PREMIUM"
   }
   

gcloud

Créez la règle de transfert en définissant le protocole sur L3_DEFAULT pour gérer tout le reste du trafic IPv4 compatible. Utilisez l'adresse IP interne réservée statique (internal-lb-ipv4) comme adresse IP interne.

gcloud compute forwarding-rules create fr-ilb-l3-default \
    --region=us-west1 \
    --load-balancing-scheme=internal \
    --network=lb-network \
    --subnet=lb-subnet \
    --address=internal-lb-ipv4 \
    --ip-protocol=L3_DEFAULT \
    --ports=ALL \
    --backend-service=be-ilb-l3-default \
    --backend-service-region=us-west1

API

Créez la règle de transfert en envoyant une requête POST à la méthode forwardingRules.insert. Remplacez PROJECT_ID par l'ID de votre projet Google Cloud.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules

{
"name": "fr-ilb-l3-default",
"IPAddress": "internal-lb-ipv4",
"IPProtocol": "L3_DEFAULT",
"ports": [
  "ALL"
],
"loadBalancingScheme": "INTERNAL",
"subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet",
"network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
"backendService": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices/be-ilb-l3-default",
"networkTier": "PREMIUM"
}