[Kubernetes] Explicación detallada del mecanismo de conmutación por error y autorreparación

I. Introducción

1. Introducción a Kubernetes

ubernetes es una plataforma de orquestación de contenedores de código abierto que puede administrar automáticamente la implementación, el escalado y la actualización de contenedores. Alivia la carga de los desarrolladores y mejora la confiabilidad y escalabilidad de las aplicaciones. Una de las razones del éxito de Kubernetes son sus capacidades automatizadas de conmutación por error y autorreparación, características que la convierten en una de las plataformas de referencia para el desarrollo de aplicaciones nativas de la nube.

2. La importancia de la conmutación por error y las capacidades de autorreparación

故障转移功能Permite que Kubernetes detecte fallas en contenedores, nodos, pods y entornos de clúster completos. Una vez que se detecta una falla, reinicia automáticamente los contenedores o reprograma los pods para garantizar la disponibilidad de la aplicación. Este mecanismo automatizado de conmutación por error mejora en gran medida la confiabilidad del sistema y reduce el tiempo de inactividad de la aplicación.

自愈能力es otra característica importante de Kubernetes que permite a Kubernetes reparar automáticamente nodos, contenedores y pods problemáticos. Cuando falla un nodo o un pod, Kubernetes los elimina temporalmente del clúster automáticamente y los vuelve a crear para garantizar la disponibilidad de la aplicación. Asimismo, cuando los nodos o contenedores fallan, Kubernetes puede moverlos automáticamente a otro nodo o reiniciarlos.

Estas capacidades reducen en gran medida la necesidad de intervención manual y mejoran en gran medida la confiabilidad y disponibilidad de la aplicación. También pueden proporcionar a las empresas un mejor soporte de operación y mantenimiento y reducir los costos de gestión. Además, la detección y transferencia automáticas de fallas también pueden mejorar las capacidades de integración y colaboración con otros servicios, mejorando aún más el rendimiento general y la confiabilidad del sistema.

En la era de la computación en la nube, la confiabilidad y la escalabilidad de las aplicaciones se vuelven imperativos en la arquitectura técnica. El uso de Kubernetes puede mejorar significativamente la eficiencia del desarrollador y la confiabilidad del sistema, lo que reduce la posibilidad de problemas de fallas e interrupciones del servicio. Por lo tanto, Kubernetes, como sistema de orquestación de contenedores de nueva generación, se ha convertido en una parte indispensable de las empresas modernas.

2. Descripción general de Kubernetes

1. Arquitectura de Kubernetes

La arquitectura de Kubernetes incluye los siguientes componentes:

• Nodo maestro:
  controla el estado y los procesos de todo el clúster y programa las aplicaciones.
• Nodos trabajadores:
  ejecutar instancias de contenedores.
• etcd:
  almacena información de estado para todo el clúster.

En la arquitectura de Kubernetes, el nodo maestro es el componente responsable de administrar y monitorear todo el clúster. Incluye los siguientes componentes básicos:

• Servidor API:
  Expone la información del estado del clúster y las interfaces que se pueden operar a través de la interfaz API REST. Todos los comandos de control de Kubernetes son reenviados a los componentes correspondientes por el servidor API.
• etcd:
  Almacena la información de estado del clúster. Es un sistema de almacenamiento de clave-valor altamente confiable y escalable utilizado por Kubernetes para almacenar la configuración, el estado y los metadatos para todo el clúster.
• Controller Manager:
  monitorea el estado del clúster y asegura que el estado esperado del sistema sea consistente con el estado real. Logra este objetivo a través de múltiples controladores, como el controlador de replicación y el controlador de punto final, etc.
• Programador:
  responsable de asignar aplicaciones a los nodos de trabajo y organizar la ubicación de las instancias de contenedor de acuerdo con la política de programación.

Los nodos de trabajo son nodos informáticos en el clúster de Kubernetes que ejecutan instancias de contenedor y son responsables de monitorear estas instancias de contenedor. Incluye los siguientes componentes:

• kubelet:
  Supervise el estado de ejecución de las instancias del contenedor e informe la información de estado al nodo principal. También analiza la información de especificaciones del contenedor para garantizar que el contenedor esté configurado correctamente y ejecuta la aplicación dentro del contenedor.
• kube-proxy:
  proxy de red, responsable de mantener las reglas de red del clúster y de enrutar las solicitudes de red a donde deben ir. Implementa balanceo de carga interno a través de iptables y responde a solicitudes de verificación de "estado" de balanceadores de carga externos con el protocolo ICMP.

2. Componentes y funciones de Kubernetes

Kubernetes proporciona los siguientes componentes y características para una mejor gestión y operación de las aplicaciones en contenedores:

• Pod:
  Pod es la unidad más básica de Kubernetes, que es una colección de uno o más contenedores. Pod tiene una dirección IP separada y un entorno independiente, y el espacio de red se comparte entre contenedores, que se pueden compartir a través de recursos como IPC y Volum.
• Servicio:
  El servicio es un mecanismo de comunicación de red entre contenedores. Puede mapear un grupo de contenedores del mismo tipo y proporcionar funciones como equilibrio de carga y descubrimiento de servicios. El servicio proporciona diferentes tipos de servicios a través de ClusterIP, NodePort y LoadBalancer.
• Volumen:
  el volumen es la abstracción de almacenamiento del contenedor, que se puede usar para datos persistentes o almacenamiento compartido.
• ReplicaSet:
  ReplicaSet garantiza que la cantidad de pods en un grupo siempre cumpla con la cantidad especificada de réplicas, que se puede usar para garantizar la recuperación automática y la disponibilidad de las aplicaciones en caso de falla.
• Implementación:
  la implementación es una extensión de ReplicaSet, que proporciona funciones como la actualización continua y la reversión.
• StatefulSet:
  StatefulSet es una secuencia de Pods. Cada Pod tiene un identificador de red independiente y es identificable. Se puede usar para aplicaciones que requieren almacenamiento persistente, implementación ordenada o sistemas de almacenamiento integrados.
• ConfigMap y Secret:
  ConfigMap y Secret son objetos que separan la información de configuración y contraseña del código fuente de la aplicación, y se pueden montar en instancias de contenedor sin estar expuestos a variables de entorno o código.

En general, Kubernetes proporciona muchas funciones que hacen que la implementación, operación y mantenimiento de aplicaciones en contenedores sean más convenientes. Con Kubernetes, puede escalar fácilmente las aplicaciones, lograr el equilibrio de carga, garantizar una alta disponibilidad y realizar operaciones como actualizaciones continuas y reversiones. Además, la funcionalidad y la eficiencia de las aplicaciones en contenedores se pueden mejorar aún más a través de una alta integración con otras herramientas y plataformas nativas de la nube, como ISTIO y Operator Framework.

3. Conmutación por error

1. Cómo definir la conmutación por error

La conmutación por error significa que cuando falla un sistema o una aplicación, automáticamente transfiere o redistribuye la carga de trabajo a otros nodos o instancias disponibles para mantener la disponibilidad y continuidad de los servicios. La conmutación por error es una característica clave de la computación en la nube y los sistemas distribuidos, que ayuda a las aplicaciones a mantener su funcionalidad y garantizar un funcionamiento sin problemas.

Los mecanismos de conmutación por error incluyen la coordinación y el monitoreo del estado de los nodos de la aplicación y su restauración automática a la operación normal en caso de falla para mantener la confiabilidad del servicio. Para lograr la conmutación por error, los sistemas y las aplicaciones pueden emplear estrategias de respaldo y redundancia, como almacenamiento de respaldo y sistemas tolerantes a fallas.

2. Mecanismo de conmutación por error en Kubernetes

Kubernetes es un sistema de orquestación de contenedores de código abierto que se puede usar para automatizar la implementación, el escalado y la administración de aplicaciones en contenedores. Proporciona varios mecanismos de conmutación por error para garantizar que las aplicaciones permanezcan disponibles y continúen ejecutándose en caso de falla.

El siguiente es el mecanismo de conmutación por error en Kubernetes:

2.1 Control de salud

Las comprobaciones de estado son una parte fundamental del mecanismo de conmutación por error de Kubernetes. Comprueba periódicamente el estado de la aplicación o del Pod dentro del contenedor para detectar fallas o bloqueos a tiempo, y reinicia o reconstruye automáticamente los Pods fallidos.

Hay tres tipos de controles de salud:

• livenessProbe: Comprueba si la aplicación dentro del contenedor está viva y responde a las solicitudes.
• readinessProbe: Comprueba si la aplicación dentro del contenedor está lista para aceptar tráfico de red.
• startupProbe: comprueba si la aplicación dentro del contenedor se está iniciando y espera un momento antes de que se complete el inicio.

2.2 Pods y conjuntos de réplicas

Pod es la unidad de implementación más pequeña de Kubernetes. Puede albergar uno o más contenedores y proporciona un entorno para compartir recursos de red y almacenamiento.

ReplicaSet es otro concepto importante en Kubernetes. Se utiliza para administrar las réplicas de Pods y garantizar que siempre se esté ejecutando la cantidad necesaria de Pods.

Si un Pod falla o se cancela, el ReplicaSet iniciará automáticamente un nuevo Pod para reemplazarlo. Esto garantiza que las aplicaciones contenedoras estén siempre disponibles en tiempo de ejecución.

2.3 Controladores y conmutación por error

En Kubernetes, un controlador es una abstracción de alto nivel que se utiliza para administrar Pods y ReplicaSets y garantizar que sus aplicaciones se comporten como se espera. Kubernetes proporciona una variedad de tipos de controladores, incluidos Deployment, StatefulSet y DaemonSet.

Un controlador puede monitorear el estado de Pods y ReplicaSets y conmutar por error o recrearlos según sea necesario. Por ejemplo, un controlador de implementación puede aumentar o reducir automáticamente la cantidad de pods para garantizar que su aplicación tenga suficientes recursos.

3. La relación entre Pods y ReplicaSets

Pod es la unidad de implementación más pequeña de Kubernetes, que puede contener uno o más contenedores y proporcionar un entorno para compartir recursos de red y almacenamiento. Un ReplicaSet es una abstracción para administrar réplicas de pods y garantizar que se esté ejecutando la cantidad necesaria de pods.

La relación entre Pod y ReplicaSet es la siguiente:

• Cada Pod es administrado por un ReplicaSet y se le debe asignar un ReplicaSet cuando se crea.
• Un ReplicaSet determina la cantidad requerida de Pods y automáticamente crea, elimina y reconstruye Pods cuando es necesario.
• Un ReplicaSet puede detectar instantáneamente un Pod fallido y reemplazarlo por uno nuevo.

4. Controladores y conmutación por error

En Kubernetes, un controlador es una abstracción de alto nivel que se utiliza para administrar Pods y ReplicaSets y garantizar que sus aplicaciones se comporten como se espera. Kubernetes proporciona una variedad de tipos de controladores, incluidos Deployment, StatefulSet y DaemonSet.

El controlador puede monitorear el estado de los Pods y los ReplicaSets y realizar una conmutación por error o una recreación según sea necesario. Por ejemplo, si un pod falla o se elimina, el controlador de implementación puede crear automáticamente un nuevo pod y garantizar que la aplicación permanezca disponible mientras se ejecuta.

Además, los controladores pueden usar capacidades de implementación continua para garantizar que las aplicaciones se actualicen sin interrupción del servicio. Cambia las nuevas versiones de los pods en función de la disponibilidad y las políticas de equilibrio de carga para garantizar que no haya fallas durante las actualizaciones de la aplicación.

4. Capacidad de autocuración

1. Cómo definir la capacidad de autocuración

La capacidad de autorreparación se refiere a la capacidad de un sistema o aplicación para monitorearse y repararse a sí mismo para mejorar la disponibilidad y confiabilidad del sistema. Cuando ocurre una falla o una situación anormal, la capacidad de autorreparación puede detectar y solucionar el problema automáticamente, lo que reduce la necesidad de una intervención manual para restaurar rápidamente el estado de funcionamiento normal. Esto puede mejorar la disponibilidad del sistema y garantizar el funcionamiento continuo y estable del sistema.

Las capacidades de recuperación automática son la base de las aplicaciones distribuidas modernas. En campos como la computación en la nube, la tecnología de contenedores y la arquitectura de microservicios, las aplicaciones complejas y a gran escala se han convertido en la norma. Estas aplicaciones contienen muchos componentes y servicios con dependencias complejas entre ellos. Cuando uno de los componentes o servicios falla, es probable que afecte el funcionamiento normal de toda la aplicación.

Por lo tanto, las capacidades de autorreparación se han convertido en una característica esencial en las aplicaciones modernas. Esta capacidad puede reducir la necesidad de intervención humana y mejorar la disponibilidad y estabilidad de la aplicación.

2. Mecanismo de autorreparación en Kubernetes

Kubernetes es un popular sistema de orquestación de contenedores que proporciona una serie de mecanismos de autorreparación para garantizar la disponibilidad y confiabilidad de las aplicaciones de contenedores. Los siguientes son algunos mecanismos comunes de autorreparación de Kubernetes:

2.1 Actualización continua automática

Las actualizaciones continuas son una forma de actualizar aplicaciones en Kubernetes. Utiliza dos versiones de la aplicación para actualizar de forma incremental todos los contenedores para evitar interrupciones y fallas momentáneas del servicio. Una actualización continua inicia la nueva versión del contenedor de la aplicación y luego detiene gradualmente la versión anterior hasta que se hayan actualizado todos los contenedores.

2.2 Expansión y contracción automática

Kubernetes puede ajustar automáticamente el número de réplicas según la carga de la aplicación para garantizar la disponibilidad del sistema. Cuando la carga es alta, automáticamente aumenta el número de réplicas; cuando la carga es muy baja, automáticamente disminuye el número de réplicas. Este mecanismo adaptativo de expansión y contracción puede garantizar la estabilidad y disponibilidad del sistema.

2.3 Tolerancia automática a fallas

Kubernetes tiene una serie de mecanismos de tolerancia a fallas, que incluyen reinicio de pod, reinicio de contenedor, reinicio de nodo, etc. Estos mecanismos pueden garantizar que la aplicación pueda recuperarse rápidamente a un estado normal en caso de falla.

2.4 Configuración de actualizaciones automáticas

Kubernetes puede actualizar automáticamente la configuración de la aplicación para garantizar que la aplicación tenga la última configuración en tiempo de ejecución. Este proceso de actualización es muy seguro, ya que garantizará que todos los pods se hayan iniciado correctamente y no interrumpirá ni perderá ninguna solicitud durante el proceso.

2.5 Reparación automática

Kubernetes tiene algunos mecanismos de autorreparación que pueden detectar y reparar automáticamente fallas o condiciones anormales en los pods. Estos mecanismos incluyen sondeos Liveness y Readiness, controles de estado de Pod y más.

3. Supervisión del estado de las cápsulas

El monitoreo Podde salud se refiere a monitorear la salud de cada contenedor en un Pod. Cuando un contenedor es anormal, Kubernetes reiniciará automáticamente el contenedor o todo el Pod según la configuración. Este mecanismo de monitoreo de salud puede garantizar que la aplicación pueda recuperarse rápidamente a un estado normal en caso de falla.

Cuando Kubernetes determina que el contenedor dentro del Pod está defectuoso, reiniciará automáticamente el contenedor a través de un mecanismo de autorreparación para restaurar tantos contenedores como sea posible a su funcionamiento normal. Si la recuperación no es posible, se cancela toda la instancia de Pod. Este mecanismo evita la necesidad de intervención manual por parte del personal de operación y mantenimiento, haciendo más perfecta la automatización.

4. ¿Qué son las sondas Liveness y Readiness?

LivenessLa sonda supervisa si el contenedor aún se está ejecutando y, si la sonda falla, Kubernetes elimina el contenedor y reinicia uno nuevo. La sonda Liveness se utiliza dentro del contenedor para resolver problemas como la animación suspendida del proceso y el interbloqueo. La sonda Liveness detecta el estado de ejecución de un contenedor enviando una solicitud a la consola del contenedor. Si la sonda recibe una respuesta, el contenedor está en buen estado; de lo contrario, el contenedor puede tener un problema y debe reiniciarse.

Readiness 探针监测容器Si se ha recibido una solicitud externa. Si la sonda falla, Kubernetes deja de enviar tráfico al contenedor, evitando así enviar solicitudes al contenedor fallido. La sonda de preparación se usa para resolver el problema de que el contenedor no puede recibir solicitudes inmediatamente cuando se inicia.

En conclusión, la capacidad de autorreparación es una característica esencial de las aplicaciones modernas. Kubernetes proporciona una serie de mecanismos de autorreparación, que incluyen actualización continua automática, expansión y contracción automáticas, tolerancia automática a fallas, reparación automática y configuración de actualización automática. La supervisión del estado de los pods y las sondas Liveness y Readiness también son mecanismos de autorreparación muy importantes en Kubernetes. Estos mecanismos pueden reducir la necesidad de intervención humana y aumentar la disponibilidad y estabilidad de las aplicaciones.
El contenido anterior se genera en un bloque de código con sintaxis marknow

5. Depuración en Kubernetes

1. Iniciar sesión en Kubernetes

En Kubernetes, el registro es una parte muy importante. Muchos componentes en un clúster de Kubernetes brindan diferentes niveles de registro que pueden indicarle qué sucede en el clúster y ayudarlo a encontrar posibles problemas. Estos son algunos componentes comunes de Kubernetes y sus ubicaciones de registro correspondientes:

• kube-apiserver: de forma predeterminada, la ubicación de registro de kube-apiserver es /var/log/kube-apiserver.log.
• kube-controller-manager: de forma predeterminada, la ubicación de registro para kube-controller-manager es /var/log/kube-controller-manager.log.
• kube-scheduler: de forma predeterminada, la ubicación de registro de kube-scheduler es /var/log/kube-scheduler.log.
• kubelet: kubelet generará registros en stdout y /var/log/kubelet.log.
• kube-proxy: la ubicación de registro predeterminada para kube-proxy es /var/log/kube-proxy.log.

Además del registro de los componentes anteriores, hay algunas otras ubicaciones de registro a considerar. Por ejemplo, las aplicaciones que se ejecutan en contenedores suelen iniciar sesión en stdout o stderr, que luego Kubernetes recopila y escribe en sus registros de Pod.

Se puede acceder a los registros de pod mediante los comandos de kubectl, por ejemplo:

kubectl logs <pod-name>

Además, existen herramientas que ayudan a recopilar y ver los registros de Kubernetes. Por ejemplo, Elasticsearch y Kibana se pueden usar para el diagnóstico y análisis centralizados de los registros de Kubernetes.

2. Capacidades de recuperación automática y conmutación por error de depuración

Kubernetes proporciona muchas capacidades de conmutación por error y autorreparación, que incluyen:

• Reiniciar contenedores automáticamente: si un contenedor falla, Kubernetes lo reiniciará automáticamente, lo que ayuda a mantener la estabilidad de la aplicación.
• Escalado automático de pods: Kubernetes puede escalar automáticamente los pods en función de métricas como la utilización de la CPU para satisfacer las necesidades de las aplicaciones.
• Conmutación por error automática: si un nodo o pod falla, Kubernetes migrará automáticamente el nodo o pod a otros nodos y restaurará el servicio a la aplicación lo antes posible.

Sin embargo, cuando Kubernetes no puede resolver automáticamente las fallas, los problemas deben rastrearse y depurarse manualmente. Estos son algunos consejos de depuración comunes:

• Ver el estado de los pods: puede usar el comando kubectl para ver el estado de los pods, por ejemplo:

kubectl get pods

Esto mostrará una lista de todos los pods y su estado actual.

• Ver eventos: puede usar el comando kubectl para ver los eventos que ocurren en el clúster, por ejemplo:

kubectl get events

Esto mostrará una lista de todos los eventos publicados en el clúster.

• Exportar registros de pod: cuando un pod se encuentra en un estado anormal, puede usar el comando kubectl para exportar registros de pod, por ejemplo:

kubectl logs <pod-name> > pod.log

Esto exportará los registros del Pod al archivo pod.log para facilitar el análisis.

• Depuración del contenedor: puede usar el comando kubectl exec para ejecutar comandos dentro del contenedor, por ejemplo:

kubectl exec <pod-name> <container-name> -- <command>

Esto ejecutará el comando dentro del contenedor.

En Kubernetes, las capacidades de recuperación automática y conmutación por error de registro y depuración son muy importantes. Al monitorear registros y eventos en su clúster, puede identificar rápidamente problemas y depurar aplicaciones. Las capacidades automáticas de conmutación por error y autorreparación de Kubernetes pueden ayudarnos a mantener la estabilidad de la aplicación, pero cuando Kubernetes no puede resolver problemas automáticamente, es necesario realizar un seguimiento y depuración manual de los problemas.

6. Mejorar las capacidades de recuperación automática y conmutación por error

1. Mejores prácticas y herramientas

En Kubernetes, para mejorar las capacidades de conmutación por error y autorreparación, se pueden adoptar las siguientes mejores prácticas y herramientas:

1.1 Usar el control de salud:

La configuración de Liveness Probe y Readiness Probe en el contenedor puede verificar periódicamente el estado de salud del contenedor y reiniciar o finalizar el contenedor según la situación. Esto ayuda a evitar que la falla de un solo contenedor derrumbe toda la aplicación.

Para utilizar las comprobaciones de estado:

1. Cree una implementación o pod de Kubernetes.

2. Defina comprobaciones de estado en implementaciones o pods.

3. Ejecute la implementación o el pod.

1.1.1 Código de muestra para una implementación que utiliza comprobaciones de estado de HTTP:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: example-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: example
  template:
    metadata:
      labels:
        app: example
    spec:
      containers:
      - name: example-container
        image: example-image
        ports:
        - containerPort: 80
        livenessProbe:
          httpGet:
            path: /healthz
            port: 80
          periodSeconds: 5
          initialDelaySeconds: 15

En este ejemplo, definimos una implementación llamada example-deployment que crea tres réplicas, cada una de las cuales contiene un contenedor llamado example-container. El contenedor usa image: example-image y escucha en el puerto 80. Además, definimos una verificación de estado HTTP que verifica que el punto final /healthz del contenedor esté disponible. LivenessProbe le dice a Kubernetes que verifique el estado del contenedor cada 5 segundos y que no comience hasta 15 segundos después de que se haya iniciado el contenedor.

4. Puede usar la herramienta de línea de comandos kubectl para ejecutar la implementación anterior:

kubectl apply -f example-deployment.yaml

En este punto, Kubernetes creará la implementación, que incluye tres pods y un servicio. Luego, Kubernetes comenzará a verificar el estado de los contenedores y los reiniciará si se vuelven defectuosos.

1.2 Ejecutar copias múltiples:

Kubernetes puede mejorar la disponibilidad y confiabilidad de las aplicaciones mediante la ejecución de varias réplicas. Esto significa que si un pod falla, Kubernetes puede escalar automáticamente las réplicas e iniciar nuevos pods, lo que garantiza que la aplicación esté siempre activa y ejecutándose en el clúster.

1.1.2 Pasos de operación para ejecutar múltiples réplicas usando Kubernetes:

1. Cree una implementación o StatefulSet.

2. Defina el número de réplicas en el archivo YAML.

3. Ejecute Deployment o StatefulSet.

Aquí hay un código de muestra para una implementación con 3 réplicas:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: example-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: example
  template:
    metadata:
      labels:
        app: example
    spec:
      containers:
      - name: example-container
        image: example-image
        ports:
        - containerPort: 80

En este ejemplo, definimos una implementación llamada example-deployment y especificamos su recuento de réplicas como 3 en la especificación. Luego, definimos un contenedor llamado example-container que usa image: example-image y escucha en el puerto 80.

4. Puede usar la herramienta de línea de comandos kubectl para ejecutar la implementación anterior:

kubectl apply -f example-deployment.yaml

Kubernetes iniciará 3 réplicas, cada una con un contenedor de ejemplo. Luego, Kubernetes puede transferir automáticamente la carga de trabajo para que el conjunto de programación se ejecute sin fallas. Si uno de los Pods no se ejecuta normalmente, Kubernetes iniciará un nuevo Pod para reemplazarlo.

Así es como Kubernetes puede mejorar la disponibilidad y confiabilidad de las aplicaciones simplemente ejecutando varias réplicas.

1.3 Usar expansión automática:

Las capacidades de escalado automático de Kubernetes pueden ayudar a hacer frente al alto tráfico, la alta simultaneidad y otras cargas, asegurando que sus aplicaciones siempre funcionen al máximo rendimiento.

1.1.3 Pasos de operación para usar Kubernetes para expandir automáticamente la capacidad:

1. Cree una implementación o StatefulSet.

2. Defina umbrales de CPU y/o memoria en un archivo YAML.

3. Configurar reglas de escalado automático.

4. Ejecute Deployment o StatefulSet.

El siguiente es un código de muestra para una implementación que se escala automáticamente en función del uso de la CPU:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: example-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: example
  template:
    metadata:
      labels:
        app: example
    spec:
      containers:
      - name: example-container
        image: example-image
        ports:
        - containerPort: 80
        resources:
          limits:
            cpu: "500m"
          requests:
            cpu: "200m"
        readinessProbe:
          httpGet:
            path: /healthz
            port: 80
          periodSeconds: 5
          initialDelaySeconds: 15
        livenessProbe:
          httpGet:
            path: /healthz
            port: 80
          periodSeconds: 5
          initialDelaySeconds: 15
      autoscaler:
        targetCPUUtilizationPercentage: 80
        minReplicas: 3
        maxReplicas: 10

En este ejemplo, definimos una implementación llamada example-deployment y especificamos el número de réplicas como 3 en la especificación. Luego definimos un contenedor que usa image: example-image y escucha en el puerto 80. Además de los contenedores, también definimos un objeto HorizontalPodAutoscaler, que configura reglas de escalado automático para ajustar la cantidad de réplicas según el uso de la CPU.

El campo targetCPUUtilizationPercentage del escalador automático establece el valor objetivo de uso de CPU en 80 %, minReplicas establece la cantidad mínima de instancias de Pod en 3 y maxReplicas establece la cantidad máxima de instancias de Pod en 10. Esto significa que cuando el uso de la CPU supere el 80 %, Kubernetes escalará automáticamente la implementación en 3 instancias de pod para alcanzar un máximo de 10 réplicas.

5. Puede usar la herramienta de línea de comandos kubectl para ejecutar la implementación anterior:

kubectl apply -f example-deployment.yaml

Kubernetes activará 3 réplicas y escalará automáticamente la implementación a medida que aumente la carga, lo que garantiza que su aplicación siempre funcione de manera óptima.

1.4 Lanzamiento en escala de grises:

La implementación en escala de grises es un método para introducir de forma incremental nuevas versiones de una aplicación en producción. Puede ayudar a reducir el riesgo de fallas y aumentar la disponibilidad de las aplicaciones. Kubernetes proporciona algunos objetos de recursos, como Implementación y Servicio, que se pueden usar para implementar la versión en escala de grises.

1.1.4 Pasos de operación para usar la versión en escala de grises de Kubernetes:

1. Cree dos implementaciones, una para la aplicación anterior y otra para la aplicación nueva.

2. Defina un Servicio en el balanceador de carga y apúntelo al Pod de implementación anterior.

3. Pruebe la funcionalidad y el rendimiento de la nueva aplicación de forma secuencial cambiando gradualmente el Servicio para que apunte a los nuevos Pods de implementación.

El siguiente es un código de muestra publicado en escala de grises:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: old-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: old-app
  template:
    metadata:
      labels:
        app: old-app
    spec:
      containers:
      - name: old-app-container
        image: old-app-image
        ports:
        - containerPort: 80

---

apiVersion: apps/v1
kind: Deployment
metadata:
  name: new-app
spec:
  replicas: 1
  selector:
    matchLabels:
      app: new-app
  template:
    metadata:
      labels:
        app: new-app
    spec:
      containers:
      - name: new-app-container
        image: new-app-image
        ports:
        - containerPort: 80

---

apiVersion: v1
kind: Service
metadata:
  name: app-service
spec:
  type: LoadBalancer
  selector:
    app: old-app
  ports:
  - name: http
    port: 80
    targetPort: 80

En este ejemplo, definimos dos implementaciones, una para la aplicación anterior llamada old-app y otra para la nueva aplicación llamada new-app. También definimos un Servicio llamado app-service, lo configuramos como un tipo de equilibrador de carga y lo apuntamos al Pod de la aplicación anterior. Esto dirigirá todo el tráfico a los pods en la aplicación anterior.

A continuación, podemos cambiar gradualmente la definición del Servicio para que apunte al Pod de la nueva aplicación. Puede hacer esto con la herramienta de línea de comandos kubectl:

En este ejemplo, definimos dos implementaciones, una para la aplicación anterior llamada old-app y otra para la nueva aplicación llamada new-app. También definimos un Servicio llamado app-service, lo configuramos como un tipo de equilibrador de carga y lo apuntamos al Pod de la aplicación anterior. Esto dirigirá todo el tráfico a los pods en la aplicación anterior.

A continuación, podemos cambiar gradualmente la definición del Servicio para que apunte al Pod de la nueva aplicación. Puede hacer esto con la herramienta de línea de comandos kubectl:

kubectl apply -f new-service.yaml

Esto utilizará el Servicio de la nueva definición para reenviar el tráfico a los Pods de la nueva aplicación. Con el tiempo, puede aumentar gradualmente la cantidad de réplicas de la nueva aplicación y cambiar el tráfico a la nueva aplicación para probar más completamente su rendimiento y funcionalidad.

1.5 Copia de seguridad y restauración de la configuración:

Kubernetes admite la copia de seguridad y la restauración sencillas de las configuraciones de la aplicación asignando ConfigMaps y Secrets a Pods. Esto puede ayudar a evitar errores al restaurar.

1.1.5 Pasos de operación para usar la copia de seguridad y recuperación de la configuración de Kubernetes:

La copia de seguridad y la recuperación de la configuración de Kubernetes pueden ayudarlo a proteger mejor su aplicación y los datos de configuración en caso de situaciones inesperadas. Estos son los pasos para configurar la copia de seguridad y la restauración con Kubernetes:

1. Crear archivos de configuración.

2. Copia de seguridad de los archivos de configuración.

3. Restaurar archivos de configuración.

Aquí hay un ejemplo de un archivo de configuración básico:

apiVersion: v1
kind: ConfigMap
metadata:
  name: app-config
data:
  app.properties: |
    database.url=jdbc:mysql://localhost/mydb
    database.username=admin
    database.password=secret

En este ejemplo, definimos un objeto ConfigMap llamado app-config. Contiene un par clave-valor llamado app.properties que contiene detalles de configuración para la aplicación, la URL de la base de datos, el nombre de usuario y la contraseña, etc.

Para hacer una copia de seguridad de los archivos de configuración, puede usar la herramienta de línea de comandos kubectl para hacer una copia de seguridad del objeto ConfigMap en un archivo YAML:

kubectl get configmaps app-config -o yaml > app-config.yaml

Esto exportará el objeto ConfigMap llamado app-config al archivo app-config.yaml para que pueda restaurarse más tarde. Puede realizar una copia de seguridad de más recursos, como Deployment y StatefulSet, según sea necesario.

Para restaurar el archivo de configuración, puede volver a importar el archivo de copia de seguridad a Kubernetes mediante la herramienta de línea de comandos kubectl:

kubectl apply -f app-config.yaml

Esto creará un nuevo objeto ConfigMap e importará los pares clave-valor definidos en el archivo app-config.yaml nuevamente al objeto.

1.6 Clase de almacenamiento de uso:

Kubernetes proporciona diferentes tipos de clases de almacenamiento, como Persistent Volume y StorageClass, que se pueden usar para implementar el almacenamiento persistente y el uso compartido de datos entre contenedores. Ayudan a proteger los datos de las migraciones de aplicaciones y las fallas de los nodos.

1.1.6 Pasos de operación para usar Kubernetes para usar clases de almacenamiento:

El siguiente es el proceso de operación básico del uso de clases de almacenamiento:

1. Cree una clase de almacenamiento.

kind: StorageClass
apiVersion: storage.k8s.io/v1
metadata:
  name: my-storage-class
provisioner: my-provisioner

donde my-storage-class es el nombre de la clase de almacenamiento y my-provisioner es el nombre de un subsistema de volumen dinámico.

2. Use clases de almacenamiento en pods.

apiVersion: v1
kind: Pod
metadata:
  name: my-pod
spec:
  containers:
  - name: my-container
    image: nginx
    volumeMounts:
    - mountPath: "/usr/share/nginx/html"
      name: my-volume
  volumes:
  - name: my-volume
    persistentVolumeClaim:
      claimName: my-claim

donde my-claim es el nombre de una reclamación de volumen persistente que utiliza la clase de almacenamiento.

3. Crea un objeto de reclamación de volumen persistente que usará la clase de almacenamiento para proporcionar almacenamiento persistente.

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: my-claim
spec:
  storageClassName: my-storage-class
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 1Gi

donde my-claim es el nombre de la reclamación de volumen persistente y my-storage-class es el nombre de la clase de almacenamiento utilizada.

2. Ejecutar aplicaciones a través de Kubernetes conduce a sistemas más confiables

Kubernetes es una tecnología de contenedorización automatizada que administra y ejecuta aplicaciones en sistemas distribuidos. Las principales ventajas de esta técnica son:

• Características como la configuración automática de nodos, descubrimiento de servicios y recuperación de fallas.
• Admite la expansión horizontal, mejorando así la tolerancia a fallas y la capacidad de carga del sistema.
• La implementación del código se puede realizar mediante actualizaciones continuas, lo que evita las interrupciones y el tiempo de inactividad de las aplicaciones.
• Proporciona balanceador de carga automatizado y detección de servicios para optimizar el tráfico y el enrutamiento de la red.
• Integre múltiples herramientas de monitoreo para detectar y resolver errores y fallas en las aplicaciones en tiempo real.

7. Conclusión

1. Resume los puntos clave

En general, este artículo describe las muchas formas en que Kubernetes puede mejorar las capacidades de conmutación por error y autorreparación, incluido el uso de comprobaciones de estado, la ejecución de varias réplicas, el escalado automático y la implementación en escala de grises, y la configuración de la copia de seguridad y la recuperación. Estos métodos están diseñados para garantizar que la aplicación esté siempre disponible y pueda recuperarse automáticamente de los errores cuando se produzcan.

Con el desarrollo de la computación en la nube y la creciente complejidad de las aplicaciones, se vuelve cada vez más importante mejorar la disponibilidad y la resiliencia de las aplicaciones. Al utilizar estos métodos proporcionados por Kubernetes, puede ayudar a las empresas a administrar y proteger mejor sus aplicaciones y datos, a fin de satisfacer mejor las necesidades y los requisitos de los usuarios.

2. Pensar en el futuro

En el futuro, a medida que la tecnología continúe avanzando y las aplicaciones evolucionen, Kubernetes puede volverse cada vez más inteligente y adoptar un enfoque más adaptable y de autorreparación para mejorar las capacidades de conmutación por error y autoreparación. Será cada vez más importante para las empresas y las personas comprender y dominar estos métodos proporcionados por Kubernetes para hacer frente al entorno cambiante de aplicaciones y tecnología.