Hinweis:

Longhorn für Kubernetes auf OKE bereitstellen

Einführung

Oracle Cloud Infrastructure Container Engine for Kubernetes (OKE) ist ein vollständig verwalteter, skalierbarer und hoch verfügbarer Service, mit dem Sie Ihre Containeranwendungen in der Cloud bereitstellen können. Sie geben die Compute-Ressourcen an, die Ihre Anwendungen benötigen, und OKE stellt sie in Oracle Cloud Infrastructure (OCI) in einem vorhandenen OCI-Mandanten bereit. Container Engine for Kubernetes verwendet Kubernetes - das Open-Source-System zur Automatisierung von Deployment, Skalierung und Verwaltung containerisierter Anwendungen auf mehreren Hostclustern.

Der OCI Block Volume-Service bietet persistenten, dauerhaften und leistungsstarken Blockspeicher für Ihre Daten. OKE kann die Block-Volumes als persistente Datenträger für Ihre Kubernetes-Umgebung verwenden und wird vollständig von OKE verwaltet. Wenn Sie die vollständige Kontrolle über die Persistent Storage-Lösung haben möchten, können Sie Longhorn auf OKE bereitstellen und als Speicherklasse verwenden. Sie erhalten vollständige Kontrolle über persistente Volumes, Skalierung, Backups und Planung.

Zielsetzung

Voraussetzungen

Aufgabe 1: OKE-Cluster erstellen

  1. Melden Sie sich bei der OCI-Konsole an, navigieren Sie zu Oracle Container Engine for Kubernetes, und klicken Sie auf Erstellen.

  2. Klicken Sie im Assistenten Cluster erstellen auf Benutzerdefinierte Erstellung.

    Benutzerdefinierte Erstellung

  3. Geben Sie den Clusternamen an, wählen Sie die zu verwendende Kubernetes-Version aus, und klicken Sie unten im Assistenten auf Weiter.

    Cluster erstellen

    Hinweis: Sie müssen VCN, Subnetze und Routen einrichten, bevor Sie mit der Clustererstellung beginnen.

    • Sie können einen der Networkingtypen auswählen. Das native VCN-Netzwerk bietet eine bessere Performance. Wenn Sie VCN-natives Networking auswählen, stellen Sie sicher, dass in Ihrem Subnetz genügend IP-Adressen verfügbar sind.

      Networkingtyp

    • Konfigurieren Sie den Knotenpool, und wählen Sie die gewünschten Compute-Ressourcen aus. Fügen Sie unter Erweiterte Optionen das unten angezeigte benutzerdefinierte Skript cloud-init ein.

      cloud-init-Skript

    • OKE bietet keine Option zum Ändern der Knotenvorlage. Um also ein Block-Volume anzuhängen, müssen Sie bei der Knoteninitialisierung ein cloud-init-Skript ausführen. Das Skript erstellt ein Block-Volume mit der angegebenen Größe und Performance und hängt es bei der Initialisierung an den Knoten an.

    • Ändern Sie die Variablen size_in_gbs (Größe des Blockspeichers, der beim Initialisieren angehängt werden soll), vpus_per_gb (vpu pro GB für den Blockspeicheranhang) und mode (Anhangsmodus, PARA oder ISCSI) im Skript entsprechend Ihren Anforderungen.

    Sie müssen eine dynamische Gruppe erstellen und dieser Gruppe Verwaltungszugriff auf Blockspeicher erteilen. Dadurch können wir die Instanz-Principal-Authentifizierung in unserem Skript verwenden.

    cloud-init-Skript:

    #!/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. Prüfen und klicken Sie auf Cluster erstellen, und warten Sie, bis das Cluster verfügbar ist.

  5. Sobald das Cluster verfügbar ist, gehen Sie zu Knotenpools und dann zu Knoten. Sie können sehen, dass sich die Knoten im Status "Bereit" befinden, auf einen beliebigen Knoten klicken, die Seite Instanzdetails öffnen, zu angehängten Block-Volumes gehen und prüfen, ob ein Block-Volume (Größe und vpu wie im Skript cloud-init angegeben) an die Instanz angehängt ist.

    Block Volume

Aufgabe 2: Longhorn einrichten

  1. Sobald das Cluster verfügbar ist, können Sie mit der cloud shell auf das Cluster zugreifen, auf Auf Cluster zugreifen klicken und den Befehl in der cloud shell kopieren und ausführen.

    Zugriff auf Cluster

  2. Führen Sie kubectl get node aus, um die Liste der planbaren Knoten abzurufen.

    Knoten abrufen

  3. Damit Longhorn die angehängte Festplatte erkennt, müssen Sie den Knoten Labels und Annotationen hinzufügen, wie unter Longhorn-Standarddatenträgersetup beschrieben. Dazu erstellen Sie eine patch.yaml-Datei, um die Knoten zu patchen.

    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. Führen Sie den folgenden Befehl für jeden Knoten aus.

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

    Knoten patchen

  5. Führen Sie den Befehl "Description node" aus, um zu prüfen, ob die Knoten gepatcht sind.

    kubectl describe node <node name>

    Knoten beschreiben

Aufgabe 3: Longhorn installieren

  1. In diesem Tutorial verwenden wir Helm, um Longhorn auf dem OKE-Cluster bereitzustellen. Befolgen Sie die Anweisungen in diesem Dokument: Mit Helm installieren.

  2. Führen Sie den folgenden Befehl aus, um Longhorn bereitzustellen.

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

    Longhorn bereitstellen

    Hinweis: Setzen Sie die Eigenschaft defaultSettings.createDefaultDiskLabeledNodes beim Deployment auf "true". Dadurch wird longhorn angewiesen, die zuvor bereitgestellte Anhängenblock-Volume-Konfiguration zu verwenden.

  3. Prüfen Sie, ob die Pods erstellt und ausgeführt werden.

    Pods prüfen

  4. Um die Benutzeroberfläche für eine bessere Ansicht von Longhorn und dessen Administration zu aktivieren, installieren Sie den Ingress-Controller wie in diesem Dokument angegeben: Beispiel: Ingress-Controller in einem Cluster einrichten.

  5. Erstellen Sie eine ingress.yaml-Datei, um die Longhorn-UI verfügbar zu machen.

    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. Führen Sie kubectl apply -f ingress.yaml aus, um die Longhorn-UI mit dem Ingress-Gateway verfügbar zu machen.

    Ingress-Gateway

  7. Rufen Sie die Gateway-URL ab, indem Sie den folgenden Befehl ausführen.

    kubectl get ingress -n longhorn-system.

    Ingress-IP

  8. Öffnen Sie die IP-Adresse in einem Browser, um auf die Longhorn-Konsole zuzugreifen und zu bestätigen, dass sie live ist.

    Longhorn-Benutzeroberfläche

    Sie können sehen, dass der Speicher verfügbar und einsatzbereit ist.

Aufgabe 4: Langhorn skalieren

Longhorn gibt Ihnen die vollständige Kontrolle über die Speicherlösung für Ihre Kubernetes-Bereitstellungen, aber die Skalierung von Longhorn ist immer noch ein manueller Prozess. Es gibt 3 Möglichkeiten, wie Sie das Longhorn-Setup skalieren können.

  1. Vergrößern Sie die Größe oder die Performanceeinheiten der angehängten Block-Volumes: Bei diesem manuellen Prozess müssen Sie jedes Block-Volume einzeln skalieren und einige Skripte auf den Knoten ausführen, um den Speicher zu erweitern. Weitere Informationen finden Sie unter Volume-Größe ändern.

  2. Mehr Volumes anhängen: Sie müssen Volumes manuell erstellen und an die Knoten anhängen.

  3. Skalieren Sie das Cluster, indem Sie die Knoten erhöhen: Da wir bereits ein cloud-init-Skript bereitgestellt haben, wird das Block-Volume erstellt und an den Knoten angehängt. Der Knoten muss gepatcht werden, nachdem er bereit ist, wie in Aufgabe 2.3 beschrieben, damit Longhorn den angeschlossenen Speicher erkennt.

Hinweis: Sie können das Skript ändern, um die gewünschte Anzahl von Block-Volumes an einen einzelnen Knoten anzuhängen.

Bestätigungen

Weitere Lernressourcen

Lernen Sie andere Übungen auf docs.oracle.com/learn kennen, oder greifen Sie auf weitere kostenlose Lerninhalte im Oracle Learning YouTube Channel zu. Besuchen Sie außerdem education.oracle.com/learning-explorer, um Oracle Learning Explorer zu werden.

Produktdokumentation finden Sie im Oracle Help Center.