Crear y depurar Sta­te­fu­l­Sets en Ku­be­r­ne­tes

Cada pod en un Sta­te­fu­l­Set de Ku­be­r­ne­tes tiene un nombre de host único y estable, así como una identidad DNS completa. Esta identidad se conserva durante los reinicios y el escalado.

¿Qué son los Sta­te­fu­l­Sets en Ku­be­r­ne­tes?

Los Sta­te­fu­l­Sets en Ku­be­r­ne­tes son entidades es­pe­cia­les para gestionar apli­ca­cio­nes que tienen re­qui­si­tos es­pe­cia­les de datos pe­r­si­s­te­n­tes e ide­n­ti­da­des fijas. Estos conjuntos ga­ra­n­ti­zan que los pods con réplicas se inicien en un orden es­pe­cí­fi­co. Los Sta­te­fu­l­Sets asignan a cada pod de Ku­be­r­ne­tes una identidad única y un acceso a al­ma­ce­na­mie­n­to pe­r­si­s­te­n­te. Estas funciones son útiles para bases de datos que dependen de re­la­cio­nes estables entre in­s­ta­n­cias y necesitan almacenar datos pe­r­si­s­te­n­tes. Los Sta­te­fu­l­Sets re­pre­se­n­tan así una solución eficaz para la or­que­s­ta­ción y el fu­n­cio­na­mie­n­to de apli­ca­cio­nes complejas en Ku­be­r­ne­tes.

Cómo crear un Sta­te­fu­l­Set en Ku­be­r­ne­tes

En primer lugar, co­me­n­za­mos de­fi­nie­n­do un archivo de co­n­fi­gu­ra­ción YAML en el que es­pe­ci­fi­ca­mos las pro­pie­da­des deseadas del Sta­te­fu­l­Set y creamos el pod de Ku­be­r­ne­tes. Tras la co­n­fi­gu­ra­ción, el Sta­te­fu­l­Set mo­ni­to­ri­za co­n­ti­nua­me­n­te el estado del clúster y se asegura de que el número pre­de­fi­ni­do de pods está siempre en ejecución y di­s­po­ni­ble. En caso de fallo o retirada de un pod del nodo, el Sta­te­fu­l­Set reconoce au­to­má­ti­ca­me­n­te la situación. En este caso, iniciará el de­s­plie­gue de un nuevo pod con la misma identidad única. Este nuevo pod se conecta al al­ma­ce­na­mie­n­to pe­r­si­s­te­n­te existente y recibe la co­n­fi­gu­ra­ción idéntica al pod original. Esto incluye también las so­li­ci­tu­des de recursos y los límites.

Esta gestión precisa de los pods y de su identidad es fu­n­da­me­n­tal para que los clientes atendidos an­te­rio­r­me­n­te por el pod no di­s­po­ni­ble puedan ser re­di­ri­gi­dos al nuevo pod sin in­te­rru­p­ción. El acceso al al­ma­ce­na­mie­n­to pe­r­si­s­te­n­te garantiza que las ope­ra­cio­nes sigan fu­n­cio­na­n­do sin problemas.

Te mostramos un archivo YAML completo que ilustra los pasos para crear un Sta­te­fu­l­Set en Ku­be­r­ne­tes para Nginx:

apiVersion: apps/v1 
kind: StatefulSet 
metadata: 
    name: nginx-statefulset 
spec: 
    serviceName: nginx 
    replicas: 3 
    selector: 
        matchLabels: 
            app: nginx 
    template: 
        metadata: 
            labels: 
                app: nginx 
        spec: 
            containers: 
            - name: nginx 
                image: nginx:latest 
                volumeMounts: 
                - name: nginx-config 
                    mountPath: /etc/nginx/conf.d 
                - name: nginx-html 
                    mountPath: /usr/share/nginx/html 
    volumeClaimTemplates: 
    - metadata: 
            name: nginx-html 
        spec: 
            accessModes: [ "ReadWriteOnce" ] 
            resources: 
                requests: 
                    storage: 1Gi 
    volumeClaimTemplates: 
    - metadata: 
            name: nginx-config 
        spec: 
            accessModes: [ "ReadWriteOnce" ] 
            resources: 
                requests: 
                    storage: 1Gi

Este documento YAML define un Sta­te­fu­l­Set en Ku­be­r­ne­tes para Nginx con tres réplicas. Utiliza un objeto de servicio llamado nginx y etiquetas para ide­n­ti­fi­car co­rre­c­ta­me­n­te los pods. Estos últimos utilizan la última imagen de Nginx y tienen dos volúmenes para los archivos de co­n­fi­gu­ra­ción y HTML. Los Vo­lu­me­Clai­m­Te­m­pla­tes aseguran el al­ma­ce­na­mie­n­to pe­r­si­s­te­n­te para estos volúmenes con un tamaño de 1 gigabyte y permiten el acceso Read­W­ri­teO­n­ce.

De­pu­ra­ción de Sta­te­fu­l­Sets

La de­pu­ra­ción de Sta­te­fu­l­Sets en Ku­be­r­ne­tes requiere pasos es­pe­cí­fi­cos para verificar que los pods se ini­cia­li­zan co­rre­c­ta­me­n­te y que es posible ide­n­ti­fi­car y corregir errores si es necesario.

Paso 1: listado de los pods

Antes de empezar a depurar Sta­te­fu­l­Sets, debes comprobar el estado de los pods.

Abre la línea de comandos y utiliza el siguiente comando para listar todos los pods del conjunto de estados deseado:

kubectl get pods -l app=statefulset-label

Output:

NAME                         READY      STATUS    RESTARTS   AGE 
nginx-statefulset-0           1/1      Running       0       2m 
nginx-statefulset-1           1/1      Running       0       1m 
nginx-statefulset-2           1/1      Running       0       1m

• NAME: cada pod recibe un nombre único basado en el esquema de nombres del Sta­te­fu­l­Set y un número co­n­se­cu­ti­vo.
• READY: indica cuántos de los co­n­te­ne­do­res deseados están listos en el pod. En el ejemplo, cada pod tiene un co­n­te­ne­dor, y 1/1 significa que el co­n­te­ne­dor está listo para su uso.
• STATUS: indica el estado actual del pod.
• RESTARTS: indica cuántas veces se ha re­ini­cia­do el co­n­te­ne­dor del pod. Un valor de 0 significa que no ha habido reinicios hasta el momento.
• AGE: indica el tiempo que lleva fu­n­cio­na­n­do el pod.

Mensajes de estado que indican errores:

• Failed (fallo): uno o más co­n­te­ne­do­res del pod causaron un error que provocó el fallo del pod. Esto puede deberse a varias razones, como la falta de de­pe­n­de­n­cias o problemas de co­n­fi­gu­ra­ción.
• Unknown (de­s­co­no­ci­do): no se ha podido de­te­r­mi­nar el estado del pod. Podría indicar un problema con la co­mu­ni­ca­ción entre el clúster de Ku­be­r­ne­tes y el pod. Esto incluye problemas de red, permisos faltantes u otros factores.

En ambos casos, es im­po­r­ta­n­te utilizar he­rra­mie­n­tas de dia­g­nó­s­ti­co precisas como la co­m­pro­ba­ción de pod logs o el comando kubectl describe pod para obtener más detalles y de­te­r­mi­nar las causas de los errores.

Paso 2: de­pu­ra­ción de pods in­di­vi­dua­les

Añadir ano­ta­cio­nes a un pod puede ser una útil he­rra­mie­n­ta de de­pu­ra­ción para influir en el proceso de ini­cia­li­za­ción o des­en­ca­de­nar acciones es­pe­cia­les.

En primer lugar, debes ide­n­ti­fi­car el nombre del pod que deseas depurar.

kubectl get pods

Anota el nombre del pod que quieres depurar.

Ahora introduce el siguiente comando en el terminal para definir la anotación para el pod se­le­c­cio­na­do:

kubectl annotate pods [pod-name] pod.alpha.kubernetes.io/initialized="false" --overwrite

Sustituye [pod-name] por el nombre real del pod. Esta anotación establece el estado de ini­cia­li­za­ción a false, lo que significa que el pod está marcado como no ini­cia­li­za­do.

Revisa el pod para ver cómo afecta la anotación a su co­m­po­r­ta­mie­n­to. En concreto, puedes comprobar los eventos y registros del pod:

kubectl describe pod [pod-name] 
kubectl logs [pod-name]

Busca eventos o salidas de registro que puedan causar problemas durante el proceso de ini­cia­li­za­ción. Cuando finalices la de­pu­ra­ción y quieras restaurar el proceso de ini­cia­li­za­ción normal, vuelve a es­ta­ble­cer la anotación en true.

Paso 3: ini­cia­li­za­ción paso a paso

Si la de­pu­ra­ción del pod uti­li­za­n­do las técnicas descritas an­te­rio­r­me­n­te no tuvo éxito, esto podría indicar race co­n­di­tio­ns durante el proceso de bootstrap del Sta­te­fu­l­Set. Para so­lu­cio­nar este problema, puedes es­pe­ci­fi­car initialized="false" en el ma­ni­fie­s­to del Sta­te­fu­l­Set de Ku­be­r­ne­tes y, a co­n­ti­nua­ción, crearlo con esta anotación en el clúster.

apiVersion: apps/v1 
kind: StatefulSet 
metadata: 
    name: [statefulset-name] 
spec: 
    template: 
        metadata: 
            annotations: 
                pod.alpha.kubernetes.io/initialized: "false" 
        ...

Aplica el ma­ni­fie­s­to ac­tua­li­za­do a tu cluster Ku­be­r­ne­tes:

kubectl apply -f statefulset.yaml

In­s­pe­c­cio­na los pods e ide­n­ti­fi­ca cualquier fuente de error. Lleva a cabo las medidas de de­pu­ra­ción ne­ce­sa­rias basándote en los eventos y registros ob­se­r­va­dos. Si es necesario, elimina los pods con kubectl delete statefulsets o kubectl delete service.

Una vez que hayas co­m­ple­ta­do la de­pu­ra­ción, podrás eliminar la anotación ini­cia­li­za­da y ac­tua­li­zar el Sta­te­fu­l­Set de Ku­be­r­ne­tes en el clúster:

kubectl annotate pods [pod-name] pod.alpha.kubernetes.io/initialized="true" --overwrite

Este comando establece la anotación ini­cia­li­za­da de un pod en true y se asegura de que se so­bre­s­cri­ban los valores exi­s­te­n­tes. Una vez co­m­pro­ba­do el primer pod, el Sta­te­fu­l­Set ini­cia­li­za­rá au­to­má­ti­ca­me­n­te el siguiente pod. A co­n­ti­nua­ción, puedes repetir los pasos de de­pu­ra­ción para cada pod adicional del Sta­te­fu­l­Set.

En este tutorial de Ku­be­r­ne­tes en­co­n­tra­rás in­fo­r­ma­ción detallada y práctica sobre la co­n­fi­gu­ra­ción de un clúster Ku­be­r­ne­tes.