Nota

Distribuisci Longhorn per Kubernetes su OKE

Introduzione

Oracle Cloud Infrastructure Container Engine for Kubernetes (OKE) è un servizio completamente gestito, scalabile e ad alta disponibilità che puoi utilizzare per distribuire le tue applicazioni containerizzate nel cloud. Puoi specificare le risorse di computazione richieste dalle tue applicazioni e OKE le esegue sul provisioning di Oracle Cloud Infrastructure (OCI) in una tenancy OCI esistente. Container Engine for Kubernetes utilizza Kubernetes, il sistema open source per automatizzare l'implementazione, la scalabilità e la gestione di applicazioni containerizzate tra cluster di host.

Il servizio OCI per volumi a blocchi fornisce storage a blocchi persistente, durevole e ad alte prestazioni per i dati e OKE può utilizzare i volumi a blocchi come dischi persistenti per l'ambiente Kubernetes ed è completamente gestito da OKE. Se si desidera avere il controllo completo della soluzione di storage persistente, è possibile distribuire Longhorn su OKE e utilizzarla come classe di storage. Ti offre il controllo completo sui volumi persistenti, il ridimensionamento, i backup e la pianificazione.

Obiettivo

Prerequisiti

Task 1: creare un cluster OKE

  1. Eseguire il login a OCI Console, passare a Oracle Container Engine for Kubernetes e fare clic su Crea.

  2. Nella procedura guidata Crea cluster fare clic su Creazione personalizzata.

    Creazione personalizzata

  3. Specificare il nome cluster, selezionare la versione di Kubernetes che si desidera utilizzare e fare clic su Avanti nella parte inferiore della procedura guidata.

    Crea cluster

    Nota: è necessario impostare la VCN, le subnet e gli instradamenti prima di iniziare con la creazione del cluster

    • È possibile scegliere uno dei tipi di rete. Il networking nativo VCN offre prestazioni migliori. Se scegli la rete nativa VCN, assicurati che la tua subnet disponga di un numero sufficiente di indirizzi IP disponibili.

      Tipo di networking

    • Configurare il pool di nodi, scegliere le risorse di calcolo desiderate. In Opzioni avanzate incollare lo script cloud-init personalizzato riportato di seguito.

      script cloud-init

    • OKE non fornisce un'opzione per modificare il modello di nodo. Pertanto, per collegare un volume a blocchi, è necessario eseguire uno script cloud-init all'inizializzazione del nodo. Lo script creerà un volume a blocchi della dimensione e delle prestazioni specificate e lo collegherà al nodo al momento dell'inizializzazione.

    • Assicurarsi di modificare le variabili size_in_gbs (dimensione dello storage a blocchi da collegare all'inizializzazione), vpus_per_gb (vpu per gb per il collegamento allo storage a blocchi) e mode (modalità collegamento, PARA o ISCSI) nello script in base alle proprie esigenze.

    È necessario creare un gruppo dinamico e fornire a questo gruppo l'accesso di gestione allo storage a blocchi. Ciò ci consente di utilizzare l'autenticazione del principal dell'istanza nel nostro 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

  4. Rivedere e fare clic su Crea cluster, quindi attendere che il cluster diventi disponibile.

  5. Una volta che il cluster è disponibile, andare a Pool di nodi, quindi a Nodi. È possibile vedere che i nodi sono in stato pronto, fare clic su qualsiasi nodo, aprirà la pagina Dettagli istanza, passerà ai volumi a blocchi collegati ed è possibile verificare che all'istanza sia collegato un volume a blocchi (di dimensioni e vpu come indicato nello script cloud-init).

    Volume a blocchi

Task 2: Impostare Longhorn

  1. Una volta che il cluster è disponibile, è possibile accedervi utilizzando la cloud shell, fare clic su Accedi al cluster e copiare ed eseguire il comando in cloud shell.

    Accesso a cluster

  2. Eseguire kubectl get node per ottenere l'elenco dei nodi programmabili.

    Recupera nodi

  3. Per consentire a Longhorn di riconoscere il disco collegato, è necessario aggiungere etichette e annotazioni ai nodi come indicato nell'impostazione predefinita del disco Longhorn. A tale scopo, verrà creato un file patch.yaml per applicare le patch ai nodi.

    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. Eseguire il comando seguente per ogni nodo.

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

    Nodo patch

  5. Eseguire il comando di descrizione del nodo per verificare che ai nodi vengano applicate le patch.

    kubectl describe node <node name>

    Descrivere il nodo

Task 3: Installa Longhorn

  1. In questa esercitazione viene utilizzato Helm per distribuire Longhorn nel cluster OKE. Seguire le istruzioni riportate in questo documento: Installa con Helm.

  2. Eseguire il comando seguente per distribuire Longhorn.

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

    Distribuisci Longhorn

    Nota: impostare la proprietà defaultSettings.createDefaultDiskLabeledNodes su true durante la distribuzione. In questo modo, Longhorn dovrà utilizzare la configurazione del volume a blocchi di collegamento fornita in precedenza.

  3. Verificare che i pod siano stati creati e in esecuzione.

    Controlla pod

  4. Per abilitare l'interfaccia utente per una migliore visualizzazione di Longhorn e della relativa amministrazione, installare Ingress Controller come indicato nel presente documento: Esempio: impostazione di un controller in entrata in un cluster.

  5. Creare un file ingress.yaml per esporre l'interfaccia utente 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. Eseguire kubectl apply -f ingress.yaml per esporre l'interfaccia utente Longhorn utilizzando il gateway in entrata.

    Gateway in entrata

  7. Ottenere l'URL del gateway eseguendo il comando seguente.

    kubectl get ingress -n longhorn-system.

    IP in entrata

  8. Aprire l'indirizzo IP da un browser per accedere alla Console Longhorn e confermare che è attiva.

    Interfaccia utente Longhorn

    Puoi vedere che abbiamo lo storage disponibile e pronto per l'uso.

Task 4: scala Longhorn

Longhorn ti offre il controllo completo della soluzione di storage per le implementazioni kubernetes, ma il ridimensionamento del longhorn è ancora un processo manuale, ci sono 3 modi in cui puoi ridimensionare la configurazione Longhorn.

  1. Aumenta le dimensioni o le unità di prestazioni dei volumi a blocchi collegati: questo è un processo manuale, devi ridimensionare ciascun volume a blocchi singolarmente ed eseguire alcuni script sui nodi per estendere lo storage. Per ulteriori informazioni, vedere Ridimensionamento di un volume.

  2. Collega più volumi: devi creare e collegare manualmente i volumi ai nodi.

  3. Ridimensionare il cluster aumentando i nodi: poiché è già stato fornito uno script cloud-init, il volume a blocchi verrà creato e collegato al nodo. È necessario applicare le patch al nodo dopo che è pronto, come indicato nel task 2.3, affinché Longhorn riconosca lo storage collegato.

Nota: è possibile modificare lo script per collegare il numero desiderato di volumi a blocchi a un singolo nodo.

Conferme

Altre risorse di apprendimento

Esplora altri laboratori su docs.oracle.com/learn o accedi a più contenuti gratuiti sulla formazione su Oracle Learning YouTube channel. Inoltre, visita education.oracle.com/learning-explorer per diventare Oracle Learning Explorer.

Per la documentazione del prodotto, visitare Oracle Help Center.