Remarques :

Ce tutoriel nécessite un accès à Oracle Cloud. Pour vous inscrire à un compte gratuit, reportez-vous à Introduction au niveau gratuit d'Oracle Cloud Infrastructure.
Il utilise des exemples de valeur pour les informations d'identification, la location et les compartiments Oracle Cloud Infrastructure. A la fin de l'exercice, remplacez ces valeurs par des valeurs propres à votre environnement cloud.

Déployer Longhorn pour Kubernetes sur OKE

Introduction

Oracle Cloud Infrastructure Container Engine for Kubernetes (OKE) est un service entièrement géré, évolutif et hautement disponible que vous pouvez utiliser pour déployer vos applications en conteneur vers le cloud. Indiquez les ressources de calcul requises par vos applications et OKE les provisionne sur Oracle Cloud Infrastructure (OCI) dans une location OCI existante. Container Engine for Kubernetes utilise Kubernetes, un système open source pour automatiser le déploiement, le redimensionnement et la gestion des applications en conteneur sur des clusters d'hôtes.

Le service OCI Block Volume fournit un stockage de blocs persistant, durable et hautes performances pour vos données. OKE peut utiliser les volumes de blocs en tant que disques persistants pour votre environnement Kubernetes et est entièrement géré par OKE. Si vous souhaitez contrôler complètement la solution de stockage persistant, vous pouvez déployer Longhorn sur OKE et l'utiliser comme classe de stockage. Il vous donne un contrôle total sur les volumes persistants, le redimensionnement, les sauvegardes et la programmation.

Objectif

Déployez et utilisez Longhorn comme solution de stockage sur OKE.

Prérequis

Accès à une location Oracle Cloud.
Réseau cloud virtuel configuré dans votre location.
Toutes les stratégies requises configurées pour OKE.

Tâche 1 : créer un cluster OKE

Connectez-vous à la console OCI, accédez à Oracle Container Engine for Kubernetes et cliquez sur Créer.
Dans l'assistant Créer un cluster, cliquez sur Création personnalisée.

Indiquez le nom du cluster, sélectionnez la version de Kubernetes à utiliser et cliquez sur Suivant au bas de l'assistant.

Créer un cluster

Remarque : vous devez configurer le VCN, les sous-réseaux et les routages avant de commencer la création du cluster

Vous pouvez choisir l'un ou l'autre des types de réseau. La mise en réseau native VCN offre de meilleures performances. Si vous choisissez la mise en réseau native VCN, assurez-vous que votre sous-réseau dispose de suffisamment d'adresses IP disponibles.

Configurez le pool de noeuds, choisissez les ressources de calcul de votre choix. Dans Options avancées, collez le script cloud-init personnalisé ci-dessous.

OKE ne fournit pas d'option permettant de modifier le modèle de noeud. Par conséquent, pour attacher un volume de blocs, vous devez exécuter un script cloud-init lors de l'initialisation du noeud. Le script crée un volume de blocs de la taille et des performances indiquées et l'attache au noeud lors de l'initialisation.

Veillez à modifier les variables size_in_gbs (taille du stockage de blocs à attacher lors de l'initialisation), vpus_per_gb (vpu par gb pour l'attachement de stockage de blocs) et mode (mode d'attachement, PARA ou ISCSI) dans le script selon vos besoins.

Vous devez créer un groupe dynamique et fournir à ce groupe un accès en gestion au stockage de blocs. Cela nous permet d'utiliser l'authentification par principal d'instance dans notre script.

Script 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

Vérifiez et cliquez sur Créer un cluster et attendez que le cluster soit disponible.
Une fois le cluster disponible, accédez à Pools de noeuds, puis à Noeuds. Vous pouvez voir que les noeuds sont prêts, cliquer sur n'importe quel noeud, ouvrir la page des détails de l'instance, accéder aux volumes de blocs attachés et vérifier qu'un volume de blocs (de taille et de CPU virtuelle comme indiqué dans le script cloud-init) est attaché à l'instance.

Tâche 2 : configurer Longhorn

Une fois le cluster disponible, vous pouvez y accéder à l'aide de cloud shell, cliquez sur Accéder au cluster, puis copiez et exécutez la commande dans cloud shell.
Exécutez kubectl get node pour obtenir la liste des noeuds planifiables.

Pour que Longhorn reconnaisse le disque connecté, nous devons ajouter des étiquettes et des annotations aux noeuds, comme indiqué dans Configuration de disque par défaut Longhorn. Pour ce faire, nous allons créer un fichier patch.yaml pour appliquer des patches aux noeuds.

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
    }
]'

Exécutez la commande suivante pour chaque noeud.

kubectl patch node <node name> --patch-file patch.yaml
Exécutez la commande describe node pour vérifier que les patches sont appliqués aux noeuds.

kubectl describe node <node name>

Tâche 3 : installation de Longhorn

Dans ce tutoriel, nous utilisons Helm pour déployer Longhorn sur le cluster OKE. Suivez les instructions mentionnées dans ce document : Install with Helm.
Exécutez la commande suivante pour déployer Longhorn.

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

Remarque : définissez la propriété defaultSettings.createDefaultDiskLabeledNodes sur True lors du déploiement. Cette opération indique à longhorn d'utiliser la configuration de volume de blocs d'attachement fournie précédemment.
Vérifiez que les pods sont créés et en cours d'exécution.
Afin d'activer l'interface utilisateur pour une meilleure vue de Longhorn et de son administration, installez le contrôleur d'entrée comme indiqué dans le document suivant : Exemple : configuration d'un contrôleur d'entrée sur un cluster.

Créez un fichier ingress.yaml pour afficher l'interface utilisateur 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

Exécutez kubectl apply -f ingress.yaml pour afficher l'interface utilisateur Longhorn à l'aide de la passerelle entrante.
Obtenez l'URL de passerelle en exécutant la commande suivante.

kubectl get ingress -n longhorn-system.
Ouvrez l'adresse IP à partir d'un navigateur pour accéder à la console Longhorn et confirmer qu'elle est active.

Vous pouvez voir que nous avons le stockage disponible et prêt à l'emploi.

Tâche 4 : échelle de Longhorn

Longhorn vous donne un contrôle complet de la solution de stockage pour vos déploiements kubernetes, mais la mise à l'échelle de longhorn est toujours un processus manuel, il existe 3 façons de mettre à l'échelle la configuration de Longhorn.

Augmenter la taille ou les unités de performances des volumes de blocs attachés : il s'agit d'un processus manuel. Vous devez redimensionner chaque volume de blocs individuellement et exécuter certains scripts sur les noeuds pour étendre le stockage. Pour plus d'informations, reportez-vous à la section Resizing a Volume.
Attacher plus de volumes : vous devez créer et attacher des volumes aux noeuds manuellement.
Redimensionnez le cluster en augmentant les noeuds : comme nous avons déjà fourni un script cloud-init, il crée le volume de blocs et l'attache au noeud. Nous devons appliquer un patch au noeud une fois qu'il est prêt, comme indiqué dans la tâche 2.3, pour que Longhorn reconnaisse le stockage attaché.

Remarque : vous pouvez modifier le script pour attacher le nombre souhaité de volumes de blocs à un seul noeud.

Remerciements

Auteur - Mayank Kakani (architecte cloud OCI)

Ressources de formation supplémentaires

Parcourez d'autres ateliers sur docs.oracle.com/learn ou accédez à davantage de contenus de formation gratuits sur le canal Oracle Learning YouTube. De plus, rendez-vous sur education.oracle.com/learning-explorer pour devenir un explorateur Oracle Learning.

Pour obtenir de la documentation sur le produit, visitez Oracle Help Center.

Informations relatives au titre et au copyright

Deploy Longhorn for Kubernetes on OKE

F76576-02

December 2023