Note:

Despliegue de Longhorn para Kubernetes en OKE

Introducción

Oracle Cloud Infrastructure Container Engine for Kubernetes (OKE) es un servicio altamente disponible, ampliable y totalmente gestionado que puede utilizar para desplegar las aplicaciones en contenedores en la nube. Especifique los recursos informáticos que necesitan sus aplicaciones y OKE los aprovisionará en Oracle Cloud Infrastructure (OCI) en un arrendamiento de OCI existente. Container Engine for Kubernetes utiliza Kubernetes: el sistema de código abierto para automatizar el despliegue, el ajuste y la gestión de aplicaciones en contenedores en clusters de hosts.

El servicio OCI Block Volume proporciona almacenamiento de bloques persistente, duradero y de alto rendimiento para sus datos, y OKE puede utilizar los volúmenes en bloque como discos persistentes para su entorno de Kubernetes y está totalmente gestionado por OKE. Si desea tener el control total de la solución de almacenamiento persistente, puede desplegar Longhorn en OKE y utilizarla como clase de almacenamiento. Ofrece un control total sobre los volúmenes persistentes, la ampliación, las copias de seguridad y la programación.

Objetivo

Requisitos

Tarea 1: Crear un cluster de OKE

  1. Conéctese a la consola de OCI, vaya a Oracle Container Engine for Kubernetes y haga clic en Crear.

  2. En el asistente Crear cluster, haga clic en Creación personalizada.

    Creación personalizada

  3. Especifique el nombre de cluster, seleccione la versión de Kubernetes que desea utilizar y haga clic en Siguiente en la parte inferior del asistente.

    Crear Cluster

    Nota: Debe configurar la VCN, las subredes y las rutas antes de empezar con la creación del cluster

    • Puede elegir cualquiera de los tipos de red. La red nativa de VCN proporciona un mejor rendimiento. Si selecciona redes nativas de VCN, asegúrese de que la subred tenga suficientes direcciones IP disponibles.

      Tipo de Red

    • Configure el pool de nodos y seleccione los recursos informáticos que desee. En Opciones avanzadas, pegue el siguiente script cloud-init personalizado.

      script cloud-init

    • OKE no proporciona una opción para modificar la plantilla de nodo, por lo que para asociar un volumen en bloque, debe ejecutar un script cloud-init al inicializar el nodo. El script creará un volumen en bloque de tamaño y rendimiento especificados y lo asociará al nodo al inicializarlo.

    • Asegúrese de modificar las variables size_in_gbs (tamaño de almacenamiento de bloques para asociar al inicio), vpus_per_gb (vpu por gb para la asociación de almacenamiento de bloques) y mode (modo de asociación, PARA o ISCSI) en el script según sus necesidades.

    Debe crear un grupo dinámico y proporcionar a este grupo acceso de gestión al almacenamiento de bloques, lo que nos permite utilizar la autenticación de principal de instancia en nuestro script.

    secuencia de comandos cloud-init:

    #!/bin/bash
curl --fail -H "Authorization: Bearer Oracle" -L0 http://169.254.169.254/opc/v2/instance/metadata/oke_init_script | base64 --decode >/var/run/oke-init.sh
bash /var/run/oke-init.sh

echo "installing python3-pip , oci sdk\n"
sudo yum install python3 -y
sudo yum install python3-pip -y
pip3 install oci
pip3 install requests

cat << EOF > pyscript.py
#!/usr/bin/python

import oci
import requests

size_in_gbs = 200
vpus_per_gb = 10
mode = 'PARA'
device_path = "/dev/oracleoci/oraclevdb"
signer = oci.auth.signers.InstancePrincipalsSecurityTokenSigner()
compute_client = oci.core.ComputeClient({}, signer = signer)
block_storage_client = oci.core.BlockstorageClient({}, signer = signer)

def get_current_instance_details():
    r = requests.get(url= 'http://169.254.169.254/opc/v1/instance')
    return r.json()

def create_volume(block_storage, compartment_id, availability_domain, display_name: str):
    print("--- creating block volume ---")
    result = block_storage.create_volume(
        oci.core.models.CreateVolumeDetails(
            compartment_id=compartment_id,
            availability_domain=availability_domain,
            display_name=display_name,
            size_in_gbs = size_in_gbs,
            vpus_per_gb = vpus_per_gb
        )
    )
    volume = oci.wait_until(
        block_storage,
        block_storage.get_volume(result.data.id),
        'lifecycle_state',
        'AVAILABLE'
    ).data
    print('--- Created Volume ocid: {} ---'.format(result.data.id))

    return volume

def attach_volume(instance_id, volume_id,device_path):
    volume_attachment_response = ""
    if mode == 'ISCSI':
        print("--- Attaching block volume {} to instance {}---".format(volume_id,instance_id))
        volume_attachment_response = compute_client.attach_volume(
            oci.core.models.AttachIScsiVolumeDetails(
                display_name='IscsiVolAttachment',
                instance_id=instance_id,
                volume_id=volume_id,
                device= device_path
                )
            )
    elif mode == 'PARA':
        volume_attachment_response = compute_client.attach_volume(
            oci.core.models.AttachParavirtualizedVolumeDetails(
            display_name='ParavirtualizedVolAttachment',
            instance_id=instance_id,
            volume_id=volume_id,
            device= device_path
        )
    )

    oci.wait_until(
        compute_client,
        compute_client.get_volume_attachment(volume_attachment_response.data.id),
        'lifecycle_state',
        'ATTACHED'
    )
    print("--- Attaching complete block volume {} to instance {}---".format(volume_id,instance_id))
    print(volume_attachment_response.data)

    # Call instance metadata uri to get current instace details
    instanceDetails = get_current_instance_details()
    print(instanceDetails)
    volume = create_volume(block_storage= block_storage_client, compartment_id= instanceDetails['compartmentId'], availability_domain=instanceDetails['availabilityDomain'], display_name= instanceDetails['displayName'])
    attach_volume(instance_id=instanceDetails['id'], volume_id=volume.id, device_path= device_path)

    EOF

    echo "running python script\n"
    chmod 755 pyscript.py
    ./pyscript.py

    echo "creating file system on volume\n"
    sudo /sbin/mkfs.ext4 /dev/oracleoci/oraclevdb
    echo "mounting volume\n"
    sudo mkdir /mnt/volume
    sudo mount /dev/oracleoci/oraclevdb /mnt/volume
    echo "adding entry to fstab\n"
    echo "/dev/oracleoci/oraclevdb /mnt/volume ext4 defaults,_netdev,nofail 0 2" |  sudo tee -a /etc/fstab

  4. Revise y haga clic en Crear cluster y espere a que el cluster esté disponible.

  5. Una vez que el cluster esté disponible, vaya a Agrupaciones de nodos y, a continuación, a Nodos. Puede ver que los nodos están en estado preparado, hacer clic en cualquier nodo, abrir la página Detalles de instancia, ir a Volúmenes en bloque asociados y verificar que un volumen en bloque (de tamaño y vpu como se menciona en el script cloud-init) está asociado a la instancia.

    Volumen en bloque

Tarea 2: Configurar Longhorn

  1. Una vez que el cluster esté disponible, puede acceder al cluster mediante Cloud Shell, hacer clic en Acceder a cluster y copiar y ejecutar el comando en Cloud Shell.

    Acceder al cluster

  2. Ejecute kubectl get node para obtener la lista de nodos programables.

    Obtener nodos

  3. Para que Longhorn reconozca el disco conectado, necesitamos agregar etiquetas y anotaciones a los nodos, como se menciona en Longhorn default disk setup. Para ello, vamos a crear un archivo patch.yaml para aplicar parches a los nodos.

    metadata:
labels:
    node.longhorn.io/create-default-disk: "config"
annotations:
    node.longhorn.io/default-disks-config: '[
    {
        "path":"/var/lib/longhorn",
        "allowScheduling":true
    },
    {
        "path":"/mnt/volume",
        "allowScheduling":true
    }
]'

  4. Ejecute el siguiente comando para cada nodo.

    kubectl patch node <node name> --patch-file patch.yaml

    Nodo de parche

  5. Ejecute el comando describe node para verificar que se han aplicado parches a los nodos.

    kubectl describe node <node name>

    Describir nodo

Tarea 3: Instalación de Longhorn

  1. En este tutorial, utilizamos Helm para desplegar Longhorn en el cluster de OKE. Siga las instrucciones mencionadas en este documento: Instalar con Helm.

  2. Ejecute el siguiente comando para desplegar Longhorn.

    helm install longhorn longhorn/longhorn --namespace longhorn-system --create-namespace --version 1.3.2 --set defaultSettings.createDefaultDiskLabeledNodes=true

    Desplegar Longhorn

    Nota: Defina la propiedad defaultSettings.createDefaultDiskLabeledNodes en true durante el despliegue. Esto indicará a longhorn que utilice la configuración de asociación de volumen en bloque proporcionada anteriormente.

  3. Verifique que los pods están creados y en ejecución.

    Comprobar pods

  4. Para activar la interfaz de usuario para obtener una mejor vista de Longhorn y su administración, instale el controlador de entrada como se menciona en este documento: Ejemplo: configuración de un controlador de entrada en un cluster.

  5. Cree un archivo ingress.yaml para mostrar la interfaz de usuario de Longhorn.

    apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
name: longhorn-ingress
namespace: longhorn-system
annotations:
    kubernetes.io/ingress.class: "nginx"
spec:
rules:
- http:
    paths:
        - path: /
        pathType: Prefix
        backend:
            service:
            name: longhorn-frontend
            port:
                number: 80

  6. Ejecute kubectl apply -f ingress.yaml para mostrar la interfaz de usuario de Longhorn mediante el gateway de entrada.

    Gateway de entrada

  7. Obtenga la URL de gateway ejecutando el siguiente comando.

    kubectl get ingress -n longhorn-system.

    IP de entrada

  8. Abra la dirección IP desde un explorador para acceder a la consola de Longhorn y confirmar que está activa.

    Interfaz de usuario de Longhorn

    Puede ver que tenemos el almacenamiento disponible y listo para usar.

Tarea 4: Escala Longhorn

Longhorn le proporciona un control completo de la solución de almacenamiento para sus despliegues de kubernetes, pero escalar longhorn sigue siendo un proceso manual, hay 3 formas de escalar la configuración de Longhorn.

  1. Aumente el tamaño o las unidades de rendimiento de los volúmenes en bloque asociados: este es un proceso manual, debe escalar cada volumen en bloque de forma individual y ejecutar algunos scripts en los nodos para ampliar el almacenamiento. Para obtener más información, consulte Cambio de tamaño de un volumen.

  2. Asocie más volúmenes: debe crear y asociar volúmenes a los nodos manualmente.

  3. Amplíe el cluster aumentando los nodos: como ya hemos proporcionado un script cloud-init, creará el volumen en bloque y lo asociará al nodo. Debemos aplicar un parche al nodo después de que esté listo, como se menciona en la tarea 2.3, para que Longhorn reconozca el almacenamiento conectado.

Nota: Puede modificar el script para asociar el número deseado de volúmenes en bloque a un solo nodo.

Agradecimientos

Más recursos de aprendizaje

Explore otros laboratorios en docs.oracle.com/learn o acceda a más contenido de aprendizaje gratuito en el canal YouTube de Oracle Learning. Además, visite education.oracle.com/learning-explorer para convertirse en Oracle Learning Explorer.

Para obtener documentación sobre el producto, visite Oracle Help Center.