Kubernetes equilibra la carga y escala las conexiones de larga duración

Un poco sobre cómo se redistribuye el tráfico en Kubernetes 

1. En el siguiente diagrama, verá tres instancias de la misma aplicación y un equilibrador de carga:
   
   
   
2. El equilibrador de carga se llama Servicio, se le asigna una dirección IP. Cualquier solicitud entrante se redirige a uno de los pods:
   
   
   
3. El script de implementación determina el número de instancias de la aplicación. Casi nunca tendrá que implementar directamente en:
   
   
   
4. A cada pod se le asigna su propia dirección IP:
   
   
   

1. Hay una solicitud curl 10.96.45.152 al servicio:
   
   
   
2. El servicio selecciona una de las tres direcciones de pod como destino:
   
   
   
3. El tráfico se redirige a un pod específico:
   
   
   

1. Bajo 1 solicita el componente interno del backend. En lugar de elegir uno específico para el backend, realiza una solicitud de servicio:
   
   
   
2. El servicio selecciona uno de los pods de back-end como la dirección de destino:
   
   
   
3. El tráfico va del hogar 1 al hogar 5 seleccionado por el servicio:
   
   
   
4. Menos de 1, no sabe exactamente cuántos hogares de menos de 5 están ocultos detrás del servicio:
   
   
   

Equilibrio en los servicios de Kubernetes

1. Considere un grupo de tres nodos. Hay pods en cada nodo:
   
   
   
2. Los hogares de punto pintados en beige son parte del servicio. Como el servicio no existe como proceso, está atenuado:
   
   
   
3. El primero solicita el servicio y debe recaer en uno de los hogares relacionados:
   
   
   
4. Pero el servicio no existe, no hay proceso. ¿Como funciona?
   
   
   
5. Antes de que la solicitud abandone el nodo, sigue las reglas de iptables:
   
   
   
6. Las reglas de iptables saben que no hay servicio y reemplazan su dirección IP con una de las direcciones IP de los pods asociados con este servicio:
   
   
   
7. La solicitud recibe una dirección IP válida como dirección de destino y normalmente se procesa:
   
   
   
8. Dependiendo de la topología de la red, la solicitud finalmente llega al hogar:
   
   
   

¿Son iptables capaces de equilibrar la carga?

1. Elija el primero con una probabilidad del 33%, de lo contrario, vaya a la siguiente regla.
2. Elija el segundo con una probabilidad del 50%, de lo contrario pase a la siguiente regla.
3. Elige el tercero debajo.

Las conexiones de larga duración en Kubernetes no se escalan de forma predeterminada

• Keep-alive en Node.js
• Mantente vivo en la bota de primavera
• Keep-alive en Python
• Keep-alive en .NET

1. El primer sub envía una solicitud al servicio:
   
   
   
2. Ya sabes lo que sucederá después. El servicio no existe, pero hay reglas de iptables que manejarán la solicitud:
   
   
   
3. Se seleccionará uno de los pods de backend como dirección de destino:
   
   
   
4. La solicitud llega al hogar. En este punto, se establecerá una conexión TCP permanente entre los dos pods:
   
   
   
5. Cualquier solicitud siguiente del primer pod pasará por una conexión ya establecida:
   
   
   

1. Obtenga la lista de puntos finales del servicio.
2. Para cada punto final, abra una conexión persistente.
3. Cuando necesite hacer una solicitud, use una de las conexiones abiertas.
4. Actualice regularmente la lista de puntos finales, cree otros nuevos o cierre conexiones persistentes antiguas si la lista cambia.

1. En lugar de enviar la primera solicitud al servicio, puede equilibrar las solicitudes en el lado del cliente:
   
   
   
2. Debe escribir un código que pregunte qué pods son parte del servicio:
   
   
   
3. Tan pronto como reciba la lista, guárdela en el lado del cliente y úsela para conectarse a los pods:
   
   
   
4. Usted mismo es responsable del algoritmo de equilibrio de carga:
   
   
   

Balanceo de carga del lado del cliente

var mysql = require('mysql');
var poolCluster = mysql.createPoolCluster();

var endpoints = /* retrieve endpoints from the Service */

for (var [index, endpoint] of endpoints) {
  poolCluster.add(`mysql-replica-${index}`, endpoint);
}

// Make queries to the clustered MySQL database

• WebSockets y WebSockets seguros
• HTTP / 2
• gRPC
• RSockets
• AMQP

Equilibrando conexiones duraderas en Kubernetes

1. Clusterip
2. NodePort
3. Loadbalancer
4. Sin cabeza

1. La capa de administración le asigna una dirección IP.
2. Kube-proxy forma las reglas necesarias de iptables.

Service Mesh te ayudará

1. Obtiene una lista de direcciones IP del servicio.
2. Abre y mantiene un grupo de conexiones.
3. Actualiza periódicamente el grupo, agregando o eliminando puntos finales.

1. Selecciona una conexión disponible utilizando algún tipo de lógica (por ejemplo, round-robin).
2. Cumple la solicitud

1. Busca automáticamente las direcciones IP de los servicios.
2. Comprueba conexiones como WebSockets y gRPC.
3. Balancea las solicitudes utilizando el protocolo correcto.

¿Qué sucede si ignoras los problemas de equilibrio?

Conclusión

1. Tres niveles de autoescalado en Kubernetes y cómo usarlos de manera efectiva . 
2. Kubernetes en el espíritu de la piratería con una plantilla de implementación .
3. Kubernetes .