Observação:

Este tutorial requer acesso ao Oracle Cloud. Para se inscrever em uma conta gratuita, consulte Conceitos básicos do Oracle Cloud Infrastructure Free Tier.
Ele usa valores de exemplo para credenciais, tenancy e compartimentos do Oracle Cloud Infrastructure. Ao concluir seu laboratório, substitua esses valores por valores específicos do seu ambiente de nuvem.

Implantar Longhorn para Kubernetes no OKE

Introdução

O Oracle Cloud Infrastructure Container Engine for Kubernetes (OKE) é um serviço totalmente gerenciado, escalável e altamente disponível que você pode usar para implantar seus aplicativos em contêineres na nuvem. Você especifica os recursos de computação necessários para seus aplicativos, e o OKE os provisiona no OCI (Oracle Cloud Infrastructure) em uma tenancy existente do OCI. O Container Engine for Kubernetes usa o Kubernetes - o sistema de código aberto para automatizar a implantação, o dimensionamento e o gerenciamento de aplicativos de contêineres em clusters de hosts.

O serviço OCI Block Volume fornece armazenamento em blocos persistente, durável e de alto desempenho para seus dados e o OKE pode utilizar os volumes em blocos como discos persistentes para seu ambiente Kubernetes e é totalmente gerenciado pelo OKE. Caso queira estar no controle total da solução de armazenamento persistente, você pode implantar o Longhorn no OKE e usá-lo como sua classe de armazenamento. Ele oferece controle completo sobre volumes persistentes, dimensionamento, backups e programação.

Objetivo

Implante e use o Longhorn como a solução de armazenamento no OKE.

Pré-requisitos

Acesso a uma tenancy do Oracle Cloud.
Uma Rede Virtual na Nuvem configurada em sua tenancy.
Toda a política necessária configurada para o OKE.

Tarefa 1: Criar um cluster do OKE

Faça log-in na Console do OCI, navegue até Oracle Container Engine for Kubernetes e clique em Criar.
No assistente de Criação de cluster, clique em Criação Personalizada.

Especifique o Nome do cluster, selecione a versão do Kubernetes que você deseja usar e clique em Próximo na parte inferior do assistente.

Criar Cluster

Observação: configure a VCN, as sub-redes e as rotas antes de iniciar a criação do cluster

Você pode escolher um dos tipos de rede. A rede nativa da VCN oferece melhor desempenho. Se você escolher a rede nativa da VCN, certifique-se de que sua sub-rede tenha endereços IP suficientes disponíveis.

Configure o pool de nós e escolha os recursos de computação desejados. Em Opções avançadas, cole o script cloud-init personalizado abaixo.

O OKE não fornece uma opção para modificar o modelo de nó; portanto, para anexar um volume em blocos, execute um script cloud-init na inicialização do nó. O script criará um volume em blocos de tamanho e desempenho especificados e o anexará ao nó na inicialização.

Certifique-se de modificar as variáveis size_in_gbs (tamanho do armazenamento em blocos a ser anexado no init), vpus_per_gb (vpu por gb para o anexo de armazenamento em blocos) e mode(modo de anexo, PARA ou ISCSI) no script de acordo com sua necessidade.

Você precisa criar um grupo dinâmico e fornecer a esse grupo acesso de gerenciamento ao armazenamento em blocos. Isso nos permite usar a autenticação do controlador de instâncias em nosso 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

Verifique e clique em Criar Cluster e aguarde até que o cluster fique disponível.
Depois que o cluster estiver disponível, vá para Pools de nós e Nós. Você pode ver que os nós estão no estado pronto, clicar em qualquer nó, abrirá a página detalhes da instância, acessará Volumes em Blocos anexados e poderá verificar se um volume em blocos (de tamanho e vpu, conforme mencionado no script cloud-init) está anexado à instância.

Tarefa 2: Configurar Longhorn

Depois que o cluster estiver disponível, você poderá acessar o cluster usando o cloud shell, clicar em Acessar Cluster e copiar e executar o comando no cloud shell.
Execute kubectl get node para obter a lista de nós programáveis.

Para que o Longhorn reconheça o disco anexado, precisamos adicionar rótulos e anotações aos Nós, conforme mencionado em Configuração de disco padrão Longhorn. Para fazer isso, vamos criar um arquivo patch.yaml para aplicar patch aos nós.

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

Execute o comando a seguir para cada nó.

kubectl patch node <node name> --patch-file patch.yaml
Execute o comando Descrever Nó para verificar se os nós foram corrigidos.

kubectl describe node <node name>

Tarefa 3: Instalar Longhorn

Neste tutorial, usamos o Helm para implantar o Longhorn no cluster do OKE. Siga as instruções mencionadas neste documento: Instalar com Helm.
Execute o seguinte comando para implantar o Longhorn.

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

Observação: Defina a propriedade defaultSettings.createDefaultDiskLabeledNodes como verdadeira durante a implantação. Isso dirá ao longhorn para usar a configuração anexar volume em blocos fornecida anteriormente.
Verifique se os pods foram criados e estão em execução.
Para ativar a IU para uma melhor exibição de Longhorn e sua administração, instale o Controlador de Entrada, conforme mencionado neste documento: Exemplo: Configurando um Controlador de Entrada em um Cluster.

Crie um arquivo ingress.yaml para expor a IU 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

Execute kubectl apply -f ingress.yaml para expor a UI Longhorn usando o gateway de Entrada.
Obtenha o url do gateway executando o comando a seguir.

kubectl get ingress -n longhorn-system.
Abra o endereço IP de um browser para acessar a Console do Longhorn e confirme se ele está ativo.

Você pode ver que temos o armazenamento disponível e pronto para uso.

Tarefa 4: Escalar Longhorn

O Longhorn oferece controle completo da solução de armazenamento para suas implementações de kubernetes, mas o dimensionamento do longhorn ainda é um processo manual, há 3 maneiras de dimensionar a configuração do Longhorn.

Aumente o tamanho ou as unidades de desempenho dos volumes em blocos anexados: Este é um processo manual, você precisa dimensionar cada volume em blocos individualmente e executar alguns scripts nos nós para estender o armazenamento. Para obter mais informações, consulte Redimensionando um Volume.
Anexar mais volumes: Você precisa criar e anexar volumes aos nós manualmente.
Dimensione o cluster aumentando os nós: Como já fornecemos um script cloud-init, ele criará o volume em blocos e o anexará ao nó. Devemos aplicar patch ao nó depois que ele estiver pronto, conforme mencionado na Tarefa 2.3, para que o Longhorn reconheça o armazenamento anexado.

Observação: você pode modificar o script para anexar o número desejado de volumes em blocos a um único nó.

Confirmações

Autor - Mayank Kakani (OCI Cloud Architect)

Mais Recursos de Aprendizagem

Explore outros laboratórios em docs.oracle.com/learn ou acesse mais conteúdo de aprendizado gratuito no canal Oracle Learning YouTube. Além disso, visite education.oracle.com/learning-explorer para se tornar um Oracle Learning Explorer.

Para obter a documentação do produto, visite o Oracle Help Center.

Título e Informações de Copyright

Deploy Longhorn for Kubernetes on OKE

F76576-02

December 2023