Créer un équilibreur de charge interne sur des réseaux VPC

Cette page explique comment créer un équilibreur de charge réseau passthrough interne sur Google Kubernetes Engine (GKE) pour plusieurs réseaux VPC.

Avant de lire ce document, assurez-vous de maîtriser les concepts suivants :

Avant de commencer

Avant de commencer, effectuez les tâches suivantes :

  • Activez l'API Google Kubernetes Engine.
    • Activer l'API Google Kubernetes Engine
  • Si vous souhaitez utiliser la Google Cloud CLI pour cette tâche, installez et initialisez la gcloud CLI. Si vous avez déjà installé la gcloud CLI, obtenez la dernière version en exécutant la commande gcloud components update. Il est possible que les versions antérieures de la gcloud CLI ne permettent pas d'exécuter les commandes de ce document.

Créer un équilibreur de charge interne avec Private Service Connect

En tant que producteur de services, vous pouvez utiliser des rattachements de service afin de rendre vos services disponibles pour les clients d'autres réseaux VPC via Private Service Connect. Vous pouvez créer, gérer et supprimer des rattachements de service à l'aide d'une ressource personnalisée ServiceAttachment. Le contrôleur GKE Private Service Connect surveille votre ressource ServiceAttachment et crée, met à jour ou supprime automatiquement une ressource ServiceAttachment correspondante dans Compute Engine.

Conditions requises et limites

  • Des limites s'appliquent à Private Service Connect.
  • Vous pouvez créer un rattachement de service dans les versions 1.21.4-gke.300 et ultérieures de GKE.
  • Le module complémentaire HttpLoadBalancing doit être activé sur votre cluster. Le module complémentaire HttpLoadBalancing est activé par défaut sur les nouveaux clusters GKE.
  • Vous ne pouvez pas utiliser le même sous-réseau dans plusieurs configurations de rattachement de service.
  • Vous devez créer un service GKE qui utilise un équilibreur de charge réseau passthrough interne.
  • Vous ne pouvez pas spécifier un sous-réseau dans un autre projet (VPC partagé) pour les versions de GKE antérieures à 1.22.4-gke.100. Pour le VPC partagé, assurez-vous que toutes les exigences de VPC partagé sont satisfaites.
  • Une fois que vous avez créé un rattachement de service, vous ne pouvez plus modifier l'équilibreur de charge interne. Pour modifier les configurations de votre équilibreur de charge, vous devez supprimer et recréer le rattachement de service.

Créer un ServiceAttachment

  1. Créez un sous-réseau.

    Vous devez créer un sous-réseau pour chaque ServiceAttachment.

    gcloud compute networks subnets create SUBNET_NAME \
    --project PROJECT_ID \
    --network NETWORK_NAME \
    --region REGION \
    --range SUBNET_RANGE \
    --purpose PRIVATE_SERVICE_CONNECT

    Remplacez les éléments suivants :

    • SUBNET_NAME : nom du nouveau sous-réseau. Dans les versions 1.22.4-gke.100 et ultérieures de GKE, vous pouvez spécifier un sous-réseau dans un autre projet en utilisant l'URL complète de la ressource pour ce champ. Vous pouvez obtenir l'URL complète de la ressource à l'aide de la commande gcloud compute networks subnets describe.
    • PROJECT_ID : ID de votre projet Cloud de Confiance.
    • NETWORK_NAME : nom du réseau VPC utilisé pour le sous-réseau.
    • REGION : région du nouveau sous-réseau. Vous devez utiliser la même région que pour le service que vous créez.
    • SUBNET_RANGE : plage d'adresses IP à utiliser pour le sous-réseau.

  2. Déployez une charge de travail.

    Le fichier manifeste suivant décrit un déploiement qui exécute un exemple d'image de conteneur d'application Web. Enregistrez le manifeste sous le nom my-deployment.yaml :

    apiVersion: apps/v1
kind: Deployment
metadata:
  name: psc-ilb
spec:
  replicas: 3
  selector:
    matchLabels:
      app: psc-ilb
  template:
    metadata:
      labels:
        app: psc-ilb
    spec:
      containers:
      - name: whereami
        image: us-docker.pkg.dev/google-samples/containers/gke/whereami:v1
        ports:
          - name: http
            containerPort: 8080
        readinessProbe:
          httpGet:
            path: /healthz
            port: 8080
            scheme: HTTP
          initialDelaySeconds: 5
          timeoutSeconds: 1

  3. Appliquez le fichier manifeste à votre cluster :

    kubectl apply -f my-deployment.yaml

  4. Créer un service Le fichier manifeste suivant décrit un service qui crée un équilibreur de charge réseau passthrough interne sur le port TCP 8080. Enregistrez le manifeste sous le nom my-service.yaml :

     apiVersion: v1
 kind: Service
 metadata:
   name: SERVICE_NAME
   annotations:
     networking.gke.io/load-balancer-type: "Internal"
 spec:
   type: LoadBalancer
   selector:
     app: psc-ilb
   ports:
   - port: 80
     targetPort: 8080
     protocol: TCP

    Remplacez les éléments suivants :

    • SERVICE_NAME : nom du nouveau service.

  5. Appliquez le fichier manifeste à votre cluster :

    kubectl apply -f my-service.yaml

  6. Créez des ServiceAttachment.

    Le fichier manifeste suivant décrit un ServiceAttachment qui expose le service que vous avez créé aux clients de service. Enregistrez le manifeste sous le nom my-psc.yaml :

    apiVersion: networking.gke.io/v1
kind: ServiceAttachment
metadata:
 name: SERVICE_ATTACHMENT_NAME
 namespace: default
spec:
 connectionPreference: ACCEPT_AUTOMATIC
 natSubnets:
 - SUBNET_NAME
 proxyProtocol: false
 reconcileConnections: false  # set to true to enable connection reconciliation
 resourceRef:
   kind: Service
   name: SERVICE_NAME

    Remplacez les éléments suivants :

    • SERVICE_ATTACHMENT_NAME : nom du nouveau rattachement de service.
    • SUBNET_NAME : nom du nouveau sous-réseau. Dans les versions 1.22.4-gke.100 et ultérieures de GKE, vous pouvez spécifier un sous-réseau dans un autre projet en utilisant l'URL complète de la ressource pour ce champ. Vous pouvez obtenir l'URL complète de la ressource à l'aide de la commande gcloud compute networks subnets describe. Pour une configuration de VPC partagé, utilisez le format suivant : projects/HOST_PROJECT_ID/regions/COMPUTE_REGION/subnetworks/SUBNET_NAME.

    Pour en savoir plus sur les champs du fichier manifeste, consultez la section Champs du rattachement de service.

  7. Appliquez le fichier manifeste à votre cluster :

    kubectl apply -f my-psc.yaml

  8. Vérifiez que le contrôleur Private Service Connect a créé le rattachement de service :

    gcloud compute service-attachments list

    La sortie affiche un rattachement de service avec un nom généré automatiquement :

    NAME        REGION       PRODUCER_FORWARDING_RULE          CONNECTION_PREFERENCE
k8s1-sa-... REGION_NAME  a3fea439c870148bdba5e59c9ea9451a  ACCEPT_AUTOMATIC

Consulter un ServiceAttachment

Vous pouvez afficher les détails d'un ServiceAttachment à l'aide de la commande suivante :

kubectl describe serviceattachment SERVICE_ATTACHMENT_NAME

Le résultat ressemble à ce qui suit :

Name:        <sa-name>
Namespace:    default
Labels:       <none>
Annotations:  <none>
API Version:  networking.gke.io/v1beta1
Kind:         ServiceAttachment
Metadata:
  ...
Status:
  Forwarding Rule URL:      https://www.googleapis.com/compute/beta/projects/<project>/regions/<region>/forwardingRules/<fr-name>
  Last Modified Timestamp:  2021-07-08T01:32:39Z
  Service Attachment URL:   https://www.googleapis.com/compute/beta/projects/<projects>/regions/<region>/serviceAttachments/<gce-service-attachment-name>
Events:                     <none>

Utiliser un ServiceAttachment

Pour utiliser votre service à partir d'un autre projet, procédez comme suit :

  1. Obtenez l'URL du ServiceAttachment :

    kubectl get serviceattachment SERVICE_ATTACHMENT_NAME -o=jsonpath="{.status.serviceAttachmentURL}"

    Le résultat ressemble à ce qui suit :

      serviceAttachmentURL: https://www.googleapis.com/compute/alpha/projects/<project>/region/<region>/serviceAttachments/k8s1-...my-sa

  2. Créez un point de terminaison Private Service Connect utilisant l'URL du ServiceAttachment.

  3. Vérifiez que vous pouvez vous connecter au service que vous avez déployé dans le projet producteur en utilisant une commande curl à partir d'une VM du projet client :

    curl PSC_IP_ADDRESS

    Remplacez PSC_IP_ADDRESS par l'adresse IP de la règle de transfert dans le projet client.

    Le résultat ressemble à ce qui suit :

    {
  "cluster_name":"cluster",
  "host_header":"10.128.15.200",
  "node_name":"gke-psc-default-pool-be9b6e0e-dvxg.c.gke_project.internal",
  "pod_name":"foo-7bf648dcfd-l5jf8",
  "pod_name_emoji":"👚",
  "project_id":"gke_project",
  "timestamp":"2021-06-29T21:32:03",
  "zone":"ZONE_NAME"
}

Mettre à jour un objet ServiceAttachment

Pour mettre à jour un élément ServiceAttachment, procédez comme suit :

  1. Modifiez le manifeste ServiceAttachment dans my-psc.yaml :

    apiVersion: networking.gke.io/v1
kind: ServiceAttachment
metadata:
  name: my-sa
  namespace: default
spec:
  connectionPreference: ACCEPT_AUTOMATIC
  natSubnets:
  - my-nat-subnet
  proxyProtocol: false
  resourceRef:
    kind: Service
    name: ilb-service

  2. Appliquez le fichier manifeste à votre cluster :

    kubectl apply -f my-psc.yaml

Supprimer un objet ServiceAttachment

Vous ne pouvez pas supprimer un équilibreur de charge réseau passthrough interne connecté à un rattachement de service. Vous devez supprimer le rattachement de service et le service GKE séparément.

  1. Supprimez le rattachement de service :

    kubectl delete serviceattachment SERVICE_ATTACHMENT_NAME --wait=false

    Cette commande marque le rattachement de service pour suppression, mais la ressource continue d'exister. Vous pouvez également attendre la fin de la suppression en omettant le flag --wait.

  2. Supprimez le service :

    kubectl delete svc SERVICE_NAME

  3. Supprimez le sous-réseau :

    gcloud compute networks subnets delete SUBNET_NAME

ServiceAttachment champs

Le champ ServiceAttachment comporte les champs suivants :

  • connectionPreference : préférence de connexion qui détermine la façon dont les clients se connectent au service. Vous pouvez utiliser l'approbation automatique du projet avec la valeur ACCEPT_AUTOMATIC ou l'approbation explicite du projet avec la valeur ACCEPT_MANUAL. Consultez Publier des services à l'aide de Private Service Connect pour en savoir plus.
  • natSubnets : liste des noms de ressources de sous-réseau à utiliser pour le rattachement de service.
  • proxyProtocol : lorsque cette valeur est définie sur "true", l'adresse IP source du client et l'ID de connexion Private Service Connect sont disponibles dans les requêtes. Ce champ est facultatif et est défini par défaut sur "false" s'il n'est pas fourni.
  • reconcileConnections (Aperçu) : lorsque cette valeur est définie sur "true", les modifications apportées aux listes d'acceptation ou de refus du client de service mettent automatiquement fin aux connexions existantes non autorisées. Lorsque cette valeur est définie sur "false", les modifications n'affectent que les nouvelles connexions. Ce champ est facultatif et est défini par défaut sur "false". Ce champ est compatible avec la version 1.36.0-gke.2459000 et les versions ultérieures de GKE.
  • consumerAllowList: liste des projets client autorisés à se connecter au ServiceAttachment. Ce champ ne peut être utilisé que lorsque la valeur de connectionPreference est définie sur ACCEPT_MANUAL. Pour plus d'informations sur ce champ, consultez Publier des services à l'aide de Private Service Connect.
    • project : ID ou numéro du projet client.
    • connectionLimit : limite de connexion du projet client. Ce champ est facultatif.
    • forceSendFields : noms des champs à inclure dans les requêtes API. Ce champ est facultatif.
    • nullFields : noms des champs à inclure dans les requêtes API avec une valeur nulle. Ce champ est facultatif.
  • consumerRejectList : liste des ID ou numéros de projet client qui ne sont pas autorisés à se connecter au ServiceAttachment. Ce champ ne peut être utilisé que lorsque la valeur de connectionPreference est définie sur ACCEPT_MANUAL. Pour plus d'informations sur ce champ, consultez Publier des services à l'aide de Private Service Connect.

  • resourceRef : référence à la ressource Kubernetes.

    • kind : type de ressource Kubernetes. Vous devez utiliser Service.
    • name : nom de la ressource Kubernetes qui doit se trouver dans le même espace de noms que l'équilibreur de charge réseau passthrough interne.

Dépannage

Vous pouvez afficher les messages d'erreur à l'aide de la commande suivante :

kubectl get events -n NAMESPACE

Remplacez NAMESPACE par l'espace de noms de l'équilibreur de charge réseau passthrough interne.

Erreur lors de la suppression de l'équilibreur de charge réseau passthrough interne

Un message d'erreur semblable à celui présenté ci-après s'affiche si vous tentez de supprimer un équilibreur de charge réseau passthrough interne utilisé par un rattachement de service. Vous devez supprimer le ServiceAttachment pour pouvoir supprimer l'équilibreur de charge réseau passthrough interne.

Error syncing load balancer: failed to ensure load balancer: googleapi:
Error 400: The forwarding_rule resource '<fwd-rule-URL>' is already being used
by '<svc-attachment-URL>', resourceInUseByAnotherResource.

Erreur lors de l'activation de l'accès mondial

Vous pouvez rencontrer une erreur lorsque vous activez l'accès mondial pour un équilibreur de charge réseau passthrough interne qui utilise un rattachement de service Private Service Connect.

Symptôme :

Lorsque vous activez l'accès mondial en mettant à jour votre fichier manifeste de service GKE et en définissant l' networking.gke.io/internal-load-balancer-allow-global-access: "true" annotation, la mise à jour échoue lorsque vous appliquez le fichier manifeste. Le message d'erreur suivant s'affiche lorsque vous exécutez la commande kubectl get events :

Error syncing load balancer: failed to ensure load balancer: googleapi: Error 400: The forwarding_rule resource '...' is already being used by '...', resourceInUseByAnotherResource

Explication :

Cette erreur se produit, car le plan de contrôle GKE tente de recréer la règle de transfert de l'équilibreur de charge pour activer l'accès mondial. Toutefois, comme la règle de transfert est utilisée par un ServiceAttachment, elle ne peut pas être supprimée ni recréée, ce qui entraîne l'erreur.

Solution :

Pour activer l'accès mondial sur l'équilibreur de charge tout en minimisant les temps d'arrêt, vous devez mettre à jour la configuration du service GKE et mettre à jour manuellement la règle de transfert :

  1. Mettez à jour le fichier manifeste du service GKE : mettez à jour votre fichier manifeste du service GKE pour inclure l' networking.gke.io/internal-load-balancer-allow-global-access: "true" annotation.

  2. Activez manuellement l'accès mondial sur la règle de transfert : suivez les étapes décrites dans Activer l'accès mondial pour mettre à jour la règle de transfert de l'équilibreur de charge à l'aide de la Cloud de Confiance console, de la Google Cloud CLI ou de l'API Compute Engine.

Champ ReconcileConnections non synchronisé

Si vous avez activé manuellement le champ ReconcileConnections sur la ressource ServiceAttachment de Compute Engine, mais que vous avez omis le champ de votre fichier manifeste Kubernetes, la valeur par défaut du champ est false. Le contrôleur GKE ne remplace alors pas la valeur du champ.

Symptôme :

La ressource ServiceAttachment Kubernetes comporte l'annotation networking.gke.io/unsynced-field: ReconcileConnections. Lorsque vous exécutez la commande kubectl get events, un événement d'avertissement semblable à celui-ci s'affiche :

Field "ReconcileConnections" is not specified in the ServiceAttachment CR but has a value in GCE. The controller will not overwrite this field until it is explicitly set in the CR.

Solution :

Pour résoudre cet avertissement et synchroniser les valeurs, effectuez l'une des actions suivantes :

  • Mettez à jour la ressource GKE ServiceAttachment : mettez à jour votre fichier manifeste GKE ServiceAttachment pour inclure reconcileConnections: true (ou false si vous souhaitez le désactiver).
  • Mettez à jour la ressource Compute Engine ServiceAttachment : définissez manuellement le champ reconcileConnections sur false.

Étape suivante