Crea un balanceador de cargas interno en las redes de VPC

Autopilot Estándar

En esta página, se explica cómo crear un balanceador de cargas de red interno en Google Kubernetes Engine (GKE) en redes de VPC. Antes de leer esta página, debes familiarizarte con los siguientes conceptos:

Antes de comenzar

Antes de comenzar, asegúrate de haber realizado las siguientes tareas:

Habilita la API de Google Kubernetes Engine.

Habilitar la API de Google Kubernetes Engine

Si deseas usar Google Cloud CLI para esta tarea, instala y, luego, inicializa gcloud CLI. Si ya instalaste gcloud CLI, ejecuta gcloud components update para obtener la versión más reciente.
Nota: Para las instalaciones de gcloud CLI existentes, asegúrate de configurar las propiedades compute/region y compute/zone. Cuando configuras las ubicaciones predeterminadas, puedes evitar errores en la gcloud CLI como el siguiente: One of [--zone, --region] must be supplied: Please specify location.

Crea un balanceador de cargas interno con Private Service Connect

Como productor de servicios, puedes usar adjuntos de servicio a fin de que tus servicios estén disponibles para los consumidores de servicios en otras redes de VPC mediante Private Service Connect. Puedes crear, administrar y borrar adjuntos de servicio mediante un recurso personalizado ServiceAttachment.

Requisitos y limitaciones

Se aplican las limitaciones para Private Service Connect.
Puedes crear un adjunto de servicio en las versiones 1.21.4-gke.300 y posteriores de GKE.
No puedes usar la misma subred para múltiples parámetros de configuración de adjuntos de servicio.
Debes crear un servicio de GKE que use un balanceador de cargas de red de transferencia interno.
No puedes especificar una subred en un proyecto diferente (VPC compartida) para versiones de GKE anteriores a la 1.22.4-gke.100. Para la VPC compartida, asegúrate de que se cumplan todos los requisitos de la VPC compartida.

Crea una `ServiceAttachment`

Crea una subred.

Debes crear una subred nueva 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
```
Reemplaza lo siguiente:
- SUBNET_NAME: es el nombre de la subred nueva. En las versiones de GKE 1.22.4-gke.100 y posteriores, puedes especificar una subred en un proyecto diferente mediante la URL de recurso completamente calificada para este campo. Puedes obtener la URL del recurso completamente calificado mediante el comando gcloud compute networks subnets describe.
- PROJECT_ID es el ID de tu proyecto de Google Cloud.
- NETWORK_NAME: es el nombre de la red de VPC para la subred.
- REGION: Es la región de la subred nueva. Debes usar la misma región que el servicio que creas.
- SUBNET_RANGE: El rango de direcciones IP que se usará para la subred.

Implementar una carga de trabajo.

En el siguiente manifiesto, se describe una implementación que ejecuta una imagen de contenedor de aplicación web de muestra. Guarda el 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.2.19
        ports:
          - name: http
            containerPort: 8080
        readinessProbe:
          httpGet:
            path: /healthz
            port: 8080
            scheme: HTTP
          initialDelaySeconds: 5
          timeoutSeconds: 1

Aplica el manifiesto al clúster:
```
kubectl apply -f my-deployment.yaml
```
Cómo crear un servicio En el siguiente manifiesto, se describe un servicio que crea un balanceador de cargas de red de transferencia interno en el puerto TCP 8080. Guarda el 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
```
Reemplaza lo siguiente:
- SERVICE_NAME: Nombre del servicio nuevo.
Aplica el manifiesto al clúster:
```
kubectl apply -f my-service.yaml
```
Crea ServiceAttachment.

En el siguiente manifiesto, se describe un ServiceAttachment que expone el servicio que creaste a los consumidores de servicios. Guarda el 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: Para las versiones de GKE anteriores a la 1.23.3-gke.900, usa networking.gke.io/v1beta1 en lugar de networking.gke.io/v1.

Reemplaza lo siguiente:
- SERVICE_ATTACHMENT_NAME: Nombre del adjunto de servicio nuevo.
- SUBNET_NAME: es el nombre de la subred nueva. En las versiones de GKE 1.22.4-gke.100 y posteriores, puedes especificar una subred en un proyecto diferente mediante la URL de recurso completamente calificada para este campo. Puedes obtener la URL del recurso completamente calificado mediante el comando gcloud compute networks subnets describe. Para una configuración de VPC compartida, usa 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 cargas de transferencia interno que define el servicio. Una vez que se aprovisiona el balanceador de cargas de red de transferencia interno, los errores ya no se publican.

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

Verifica que el controlador de Private Service Connect haya creado el adjunto de servicio:

gcloud beta compute service-attachments list

El resultado muestra un adjunto de servicio con un nombre generado automáticamente:

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

Ve un `ServiceAttachment`

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

kubectl describe serviceattachment SERVICE_ATTACHMENT_NAME

El resultado es similar a este:

 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>

Consume un `ServiceAttachment`

Para consumir tu servicio desde otro proyecto, realiza los siguientes pasos:

Obtén la URL del ServiceAttachment:

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

El resultado es similar a este:

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

Crea un extremo de Private Service Connect con la URL de ServiceAttachment.

Verifica que puedas conectarte al servicio que implementaste en el proyecto de productor mediante un comando curl desde una VM en el proyecto de consumidor:

curl PSC_IP_ADDRESS

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

El resultado es similar a este:

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

Actualiza una `ServiceAttachment`

Puedes actualizar un ServiceAttachment mediante los siguientes pasos:

Edita el 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 al clúster:
```
kubectl apply -f my-psc.yaml
```

Borra una `ServiceAttachment`

No puedes borrar un balanceador de cargas de red de transferencia interno que esté conectado a un adjunto de servicio. Debes borrar el adjunto de servicio y el servicio de GKE por separado.

Borra el adjunto de servicio:
```
kubectl delete serviceattachment SERVICE_ATTACHMENT_NAME --wait=false
```
Con este comando, se marca el adjunto de servicio para su eliminación, pero el recurso continúa existiendo. También puedes esperar a que finalice la eliminación si omites la marca --wait.
Borrar Service:
```
kubectl delete svc SERVICE_NAME
```

Borra la subred:

gcloud compute networks subnets delete SUBNET_NAME

Campos `ServiceAttachment`

ServiceAttachment tiene los siguientes campos:

connectionPreference: es la preferencia de conexión que determina cómo los clientes se conectan al servicio. Puedes usar la aprobación automática del proyecto con ACCEPT_AUTOMATIC o la aprobación explícita del proyecto con ACCEPT_MANUAL. Para obtener más información, consulta Publica servicios mediante Private Service Connect.
natSubnets: una lista de nombres de recursos de subred para usar en el adjunto de servicio.
proxyProtocol: cuando se configura como verdadero, la IP de origen del consumidor y la ID de conexión de Private Service Connect están disponibles en las solicitudes. Este campo es opcional y su valor predeterminado es falso si no se proporciona.
consumerAllowList: es 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 Publica servicios mediante Private Service Connect.
- project: El número o ID del proyecto de consumidor.
- connectionLimit: es el límite de conexión para el proyecto de consumidor. Este campo es opcional.
- forceSendFields: son los nombres de campo que se enviarán a fin de incluir en las solicitudes a la API. Este campo es opcional.
- nullFields: son los nombres de campo que se incluirán en las solicitudes a la API con un valor nulo. Este campo es opcional.
consumerRejectList: es la lista de ID o números de proyectos de consumidor que no 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 Publica servicios mediante Private Service Connect.
resourceRef: Una referencia al recurso de Kubernetes.
- kind: es el tipo de recurso de Kubernetes. Debes usar Service.
- name: es el nombre del recurso de Kubernetes que debe estar en el mismo espacio de nombres que el balanceador de cargas de red de transferencia interno.
Nota: Una vez que un adjunto de servicio se conecta a un balanceador de cargas de red de transferencia interno, no puedes borrar ni actualizar el balanceador de cargas de red de transferencia interno. Si intentas borrar o actualizar el balanceador de cargas de red de transferencia interno, aparecerá un mensaje de error. Si deseas obtener más información, consulta Solución de problemas.

Soluciona problemas

Puedes ver los mensajes de error mediante el siguiente comando:

kubectl get events -n NAMESPACE

Reemplaza NAMESPACE por el espacio de nombres del balanceador de cargas de red de transferencia interno.

Aparece un mensaje de error similar al siguiente si intentas borrar un balanceador de cargas de red de transferencia interno que está usando un adjunto de servicio. Debes borrar ServiceAttachment para poder borrar el balanceador de cargas de red de transferencia 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.

¿Qué sigue?

Consulta la descripción general de la red GKE.
Más información sobre el balanceador de cargas de Compute Engine.
Obtén información para crear un clúster nativo de la VPC.
Obtén información sobre cómo configurar redes autorizadas.

Crea un balanceador de cargas interno en las redes de VPC

Antes de comenzar

Crea un balanceador de cargas interno con Private Service Connect

Requisitos y limitaciones

Crea una ServiceAttachment

Ve un ServiceAttachment

Consume un ServiceAttachment

Actualiza una ServiceAttachment

Borra una ServiceAttachment

Campos ServiceAttachment

Soluciona problemas

¿Qué sigue?

Crea una `ServiceAttachment`

Ve un `ServiceAttachment`

Consume un `ServiceAttachment`

Actualiza una `ServiceAttachment`

Borra una `ServiceAttachment`

Campos `ServiceAttachment`