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

Autopilot Standard

Cette page explique comment créer un équilibreur de charge réseau passthrough interne sur Google Kubernetes Engine (GKE) sur plusieurs réseaux VPC. Avant de lire cette page, vous devez connaître 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 Google Cloud CLI pour cette tâche, installez puis initialisez gcloud CLI. Si vous avez déjà installé gcloud CLI, assurez-vous de disposer de la dernière version en exécutant la commande gcloud components update.
Remarque : Pour les installations de gcloud CLI existantes, veillez à définir les propriétés compute/region et compute/zone. En définissant des emplacements par défaut, vous pouvez éviter les erreurs gcloud CLI telles que celle-ci : One of [--zone, --region] must be supplied: Please specify location.

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.

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.
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 remplies.

Créer un objet `ServiceAttachment`

Créez un sous-réseau.

Vous devez créer un sous-réseau pour chaque objet ServiceAttachment.
```
gcloud beta 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 Google Cloud.
- 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 celle du service que vous créez.
- SUBNET_RANGE : plage d'adresses IP à utiliser pour le sous-réseau.

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.2.19
        ports:
          - name: http
            containerPort: 8080
        readinessProbe:
          httpGet:
            path: /healthz
            port: 8080
            scheme: HTTP
          initialDelaySeconds: 5
          timeoutSeconds: 1

Appliquez le fichier manifeste à votre cluster :
```
kubectl apply -f my-deployment.yaml
```
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.
Appliquez le fichier manifeste à votre cluster :
```
kubectl apply -f my-service.yaml
```
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
 resourceRef:
   kind: Service
   name: SERVICE_NAME
```
Remarque : Pour les versions de GKE antérieures à 1.23.3-gke.900, utilisez networking.gke.io/v1beta1 au lieu de networking.gke.io/v1.

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.
Remarque : La ressource ServiceAttachment génère des événements d'erreur jusqu'à ce que le contrôleur GKE crée l'équilibreur de charge réseau passthrough interne défini par le service. Une fois l'équilibreur de charge réseau passthrough interne provisionné, les erreurs ne sont plus publiées.

Pour en savoir plus sur les champs du fichier manifeste, consultez la section Champs du rattachement de service.
Appliquez le fichier manifeste à votre cluster :
```
kubectl apply -f my-psc.yaml
```

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

gcloud beta 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 :

 kubectl describe serviceattachment foo-sa
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 :

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

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

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 du 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 :

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

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.

Supprimez le rattachement de service :
```
kubectl delete serviceattachment SERVICE_ATTACHMENT_NAME --wait=false
```
Cette commande marque le rattachement de service à supprimer, mais la ressource continue d'exister. Vous pouvez également attendre la fin de la suppression en omettant l'option --wait.
Supprimez le service :
```
kubectl delete svc SERVICE_NAME
```

Supprimez le sous-réseau :

gcloud compute networks subnets delete SUBNET_NAME

Champs `ServiceAttachment`

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 la page 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.
consumerAllowList : liste des projets de consommateur 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 la section 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 du projet client qui ne sont pas autorisés à se connecter à 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 la section 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.
Remarque : Une fois qu'un rattachement de service est connecté à un équilibreur de charge réseau passthrough interne, vous ne pouvez plus supprimer ni mettre à jour l'équilibreur de charge réseau passthrough interne. Si vous tentez de supprimer ou de mettre à jour l'équilibreur de charge réseau passthrough interne, un message d'erreur s'affiche. Pour en savoir plus, consultez la section Dépannage.

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.

Un message d'erreur semblable à celui 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 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.

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

Avant de commencer

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

Conditions requises et limites

Créer un objet ServiceAttachment

Consulter un ServiceAttachment

Utiliser un ServiceAttachment

Mettre à jour un objet ServiceAttachment

Supprimer un objet ServiceAttachment

Champs ServiceAttachment

Dépannage

Étapes suivantes

Créer un objet `ServiceAttachment`

Consulter un `ServiceAttachment`

Utiliser un `ServiceAttachment`

Mettre à jour un objet `ServiceAttachment`

Supprimer un objet `ServiceAttachment`

Champs `ServiceAttachment`