Esta página se ha traducido con Cloud Translation API.

Crear un balanceador de carga interno en redes VPC

Autopilot Standard

En esta página se explica cómo crear un balanceador de carga de red de pases interno en Google Kubernetes Engine (GKE) en redes de VPC.

Antes de leer esta página, asegúrate de que conoces los siguientes conceptos:

Antes de empezar

Antes de empezar, asegúrate de que has realizado las siguientes tareas:

Habilita la API de Google Kubernetes Engine.

Habilitar la API de Google Kubernetes Engine

Si quieres usar Google Cloud CLI para esta tarea, instálala y, a continuación, inicialízala. Si ya has instalado la gcloud CLI, obtén la versión más reciente ejecutando gcloud components update.
Nota: Si ya tienes instalada la CLI de gcloud, asegúrate de definir la compute/region propiedad. Si usas principalmente clústeres zonales, define compute/zone en su lugar. Si defines una ubicación predeterminada, puedes evitar errores en gcloud CLI como el siguiente: One of [--zone, --region] must be supplied: Please specify location. Es posible que tengas que especificar la ubicación en determinados comandos si la ubicación de tu clúster es diferente de la predeterminada que hayas definido.

Crear un balanceador de carga interno con Private Service Connect

Como productor de servicios, puedes usar vinculaciones de servicio para que tus servicios estén disponibles para los consumidores de servicios de otras redes de VPC mediante Private Service Connect. Puedes crear, gestionar y eliminar archivos adjuntos de servicio mediante un recurso personalizado de ServiceAttachment.

Requisitos y limitaciones

Se aplican las limitaciones de Private Service Connect.
Puedes crear un acoplamiento de servicio en las versiones de GKE 1.21.4-gke.300 y posteriores.
Tu clúster debe tener habilitado el HttpLoadBalancing complemento. Los clústeres de GKE nuevos tienen el complemento HttpLoadBalancing habilitado de forma predeterminada.
No puedes usar la misma subred en varias configuraciones de adjuntos de servicio.
Debes crear un servicio de GKE que use un balanceador de carga de red de paso a través interno.
No puedes especificar una subred de otro proyecto (VPC compartida) para versiones de GKE anteriores a la 1.22.4-gke.100. En el caso de las VPC compartidas, asegúrate de que se cumplen todos los requisitos de las VPC compartidas.
Después de crear un acoplamiento de servicio, no puedes actualizar el balanceador de carga interno. Para cambiar las configuraciones de tu balanceador de carga, debes eliminar y volver a crear el adjunto de servicio.

Crear un `ServiceAttachment`

Crea una subred.

Debes crear una subred para cada ServiceAttachment.
```
gcloud beta compute networks subnets create SUBNET_NAME \
    --project PROJECT_ID \
    --network NETWORK_NAME \
    --region REGION \
    --range SUBNET_RANGE \
    --purpose PRIVATE_SERVICE_CONNECT
```
Haz los cambios siguientes:
- SUBNET_NAME: el nombre de la nueva subred. En las versiones 1.22.4-gke.100 y posteriores de GKE, puedes especificar una subred de otro proyecto mediante la URL de recurso completa de este campo. Puedes obtener la URL completa del recurso con el comando gcloud compute networks subnets describe.
- PROJECT_ID: el ID de tu proyecto de Google Cloud.
- NETWORK_NAME: el nombre de la red VPC de la subred.
- REGION: la región de la nueva subred. Debes usar la misma región que el servicio que crees.
- SUBNET_RANGE: el intervalo de direcciones IP que se va a usar en la subred.

Despliega una carga de trabajo.

El siguiente manifiesto describe un Deployment que ejecuta una imagen de contenedor de una aplicación web de ejemplo. Guarda el archivo de manifiesto como 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

Aplica el manifiesto a tu clúster:
```
kubectl apply -f my-deployment.yaml
```

Crea un servicio. El siguiente manifiesto describe un servicio que crea un balanceador de carga de red de paso a través interno en el puerto TCP 8080. Guarda el archivo de manifiesto como 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

Haz los cambios siguientes:

SERVICE_NAME: el nombre del nuevo servicio.

Aplica el manifiesto a tu clúster:
```
kubectl apply -f my-service.yaml
```
Crear ServiceAttachment.

El siguiente manifiesto describe un ServiceAttachment que expone el servicio que has creado a los consumidores del servicio. Guarda el archivo de manifiesto como 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
```
Nota: En las versiones de GKE anteriores a la 1.23.3-gke.900, usa networking.gke.io/v1beta1 en lugar de networking.gke.io/v1.

Haz los cambios siguientes:
- SERVICE_ATTACHMENT_NAME: el nombre del nuevo servicio adjunto.
- SUBNET_NAME: el nombre de la nueva subred. En las versiones 1.22.4-gke.100 y posteriores de GKE, puedes especificar una subred de otro proyecto mediante la URL de recurso completa de este campo. Puedes obtener la URL completa del recurso con el comando gcloud compute networks subnets describe. En el caso de una configuración de VPC compartida, utiliza el siguiente formato: projects/HOST_PROJECT_ID/regions/COMPUTE_REGION/subnetworks/SUBNET_NAME.
Nota: El recurso ServiceAttachment tendrá eventos de error hasta que el controlador de GKE cree el balanceador de carga de red pasarela interno definido por el servicio. Una vez aprovisionado el balanceador de carga de red de paso a través interno, los errores ya no se publican.

Para obtener más información sobre los campos del manifiesto, consulta los campos de adjunto de servicio.
Aplica el manifiesto a tu clúster:
```
kubectl apply -f my-psc.yaml
```

Verifica que el controlador de Private Service Connect haya creado la vinculación de servicio:

gcloud beta compute service-attachments list

En la salida se muestra una vinculación de servicio con un nombre generado automáticamente:

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

Ver un `ServiceAttachment`

Puedes ver los detalles de un ServiceAttachment con el siguiente comando:

kubectl describe serviceattachment SERVICE_ATTACHMENT_NAME

El resultado debería ser similar al siguiente:

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>

Consumir un `ServiceAttachment`

Para consumir tu servicio desde otro proyecto, sigue estos pasos:

Obtén la URL de ServiceAttachment:

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

El resultado debería ser similar al siguiente:

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

Crea un endpoint de Private Service Connect con la URL del ServiceAttachment.

Verifica que puedes conectarte al servicio que has desplegado en el proyecto de productor mediante el comando curl desde una VM del proyecto de consumidor:

curl PSC_IP_ADDRESS

Sustituye PSC_IP_ADDRESS por la dirección IP de la regla de reenvío del proyecto del consumidor.

El resultado debería ser similar al siguiente:

{
  "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"
}

Actualizar un `ServiceAttachment`

Para actualizar un ServiceAttachment, sigue estos pasos:

Edita el archivo de manifiesto ServiceAttachment en 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

Aplica el manifiesto a tu clúster:
```
kubectl apply -f my-psc.yaml
```

Eliminar un `ServiceAttachment`

No puedes eliminar un balanceador de carga de red de paso a través interno que esté conectado a un adjunto de servicio. Debes eliminar el adjunto de servicio y el servicio de GKE por separado.

Elimina el archivo adjunto del servicio:
```
kubectl delete serviceattachment SERVICE_ATTACHMENT_NAME --wait=false
```
Este comando marca el adjunto de servicio para que se elimine, pero el recurso sigue existiendo. También puedes esperar a que se complete la eliminación omitiendo la marca --wait.
Elimina el servicio:
```
kubectl delete svc SERVICE_NAME
```

Elimina la subred:

gcloud compute networks subnets delete SUBNET_NAME

`ServiceAttachment` campos

El ServiceAttachment tiene los siguientes campos:

connectionPreference: la preferencia de conexión que determina cómo se conectan los clientes al servicio. Puedes usar la aprobación automática de proyectos con ACCEPT_AUTOMATIC o la aprobación explícita de proyectos con ACCEPT_MANUAL. Para obtener más información, consulta Publicar servicios mediante Private Service Connect.
natSubnets: lista de nombres de recursos de subredes que se van a usar en el adjunto de servicio.
proxyProtocol: si se define como true, la IP de origen del consumidor y el ID de conexión de Private Service Connect estarán disponibles en las solicitudes. Este campo es opcional y su valor predeterminado es false si no se proporciona.
consumerAllowList: la lista de proyectos de consumidor que pueden conectarse a ServiceAttachment. Este campo solo se puede usar cuando connectionPreference es ACCEPT_MANUAL. Para obtener más información sobre este campo, consulta Publicar servicios mediante Private Service Connect.
- project: el ID o el número del proyecto del consumidor.
- connectionLimit: el límite de conexiones del proyecto consumidor. Este campo es opcional.
- forceSendFields: los nombres de los campos que se van a enviar para incluirlos en las solicitudes de la API. Este campo es opcional.
- nullFields: los nombres de los campos que se incluirán en las solicitudes de la API con un valor nulo. Este campo es opcional.
consumerRejectList: la lista de IDs o números de proyectos de consumidor que no pueden conectarse al ServiceAttachment. Este campo solo se puede usar cuando connectionPreference es ACCEPT_MANUAL. Para obtener más información sobre este campo, consulta Publicar servicios mediante Private Service Connect.
resourceRef: una referencia al recurso de Kubernetes.
- kind: el tipo de recurso de Kubernetes. Debes usar Service.
- name: nombre del recurso de Kubernetes que debe estar en el mismo espacio de nombres que el balanceador de carga de red de paso a través interno.
Nota: Una vez que un adjunto de servicio se ha conectado a un balanceador de carga de red de paso a través interno, no puedes eliminar ni actualizar el balanceador de carga de red de paso a través interno. Si intentas eliminar o actualizar el balanceador de carga de red interno de pasarela, aparecerá un mensaje de error. Para obtener más información, consulta la sección Solución de problemas.

Solución de problemas

Puedes ver los mensajes de error con el siguiente comando:

kubectl get events -n NAMESPACE

Sustituye NAMESPACE por el espacio de nombres del balanceador de carga de red de paso a través interno.

Error al eliminar un balanceador de carga de red de paso a través interno

Si intentas eliminar un balanceador de carga de red interno de transferencia que está usando un adjunto de servicio, se producirá un mensaje de error similar al siguiente: Debes eliminar el ServiceAttachment antes de eliminar el balanceador de carga de red de pasarela interno.

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.

Error al habilitar el acceso global

Puede que se produzca un error al habilitar global access en un balanceador de carga de red interno de tipo pasarela que utilice un archivo adjunto de servicio de Private Service Connect.

Síntoma:

Si habilitas el acceso global actualizando el manifiesto de tu servicio de GKE y definiendo la anotación networking.gke.io/internal-load-balancer-allow-global-access: "true", la actualización fallará cuando apliques el manifiesto. Aparece el siguiente mensaje de error al ejecutar el comando 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

Motivo:

Este error se produce porque el plano de control de GKE intenta volver a crear la regla de reenvío del balanceador de carga para habilitar el acceso global. Sin embargo, como la regla de reenvío está en uso por un ServiceAttachment, no se puede eliminar ni volver a crear, lo que provoca el error.

Solución alternativa:

Para habilitar el acceso global en el balanceador de carga y minimizar el tiempo de inactividad, debes actualizar la configuración del servicio de GKE y actualizar manualmente la regla de reenvío:

Actualiza el manifiesto de servicio de GKE: actualiza el manifiesto de servicio de GKE para incluir la anotación networking.gke.io/internal-load-balancer-allow-global-access: "true".
Habilita manualmente el acceso global en la regla de reenvío: sigue los pasos que se indican en Habilitar el acceso global para actualizar la regla de reenvío del balanceador de carga con la consola deGoogle Cloud , la CLI de Google Cloud o la API de Compute Engine.

Crear un balanceador de carga interno en redes VPC Organízate con las colecciones Guarda y clasifica el contenido según tus preferencias.

Antes de empezar

Crear un balanceador de carga interno con Private Service Connect

Requisitos y limitaciones

Crear un ServiceAttachment

Ver un ServiceAttachment

Consumir un ServiceAttachment

Actualizar un ServiceAttachment

Eliminar un ServiceAttachment

ServiceAttachment campos

Solución de problemas

Error al eliminar un balanceador de carga de red de paso a través interno

Error al habilitar el acceso global

Siguientes pasos

Crear un balanceador de carga interno en redes VPC

Crear un `ServiceAttachment`

Ver un `ServiceAttachment`

Consumir un `ServiceAttachment`

Actualizar un `ServiceAttachment`

Eliminar un `ServiceAttachment`

`ServiceAttachment` campos