Provisionar o Managed Lustre no GKE usando o XPK

Este documento explica como integrar o Managed Lustre ao GKE para criar um ambiente otimizado para cargas de trabalho exigentes e com uso intensivo de dados, como inteligência artificial (IA), machine learning (ML) e computação de alto desempenho (HPC).

Neste documento, você provisiona um cluster do GKE com XPK, cria uma instância gerenciada do Lustre e a anexa ao cluster. Para testar essa configuração, execute uma carga de trabalho em nós provisionados com flex-start.

Este documento é destinado a engenheiros de machine learning (ML) e especialistas em dados e IA interessados em conhecer os recursos de orquestração de contêineres do Kubernetes com suporte de instâncias gerenciadas do Lustre. Para saber mais sobre papéis comuns e exemplos de tarefas referenciados no conteúdo do Google Cloud , consulte Funções e tarefas comuns do usuário do GKE.

Contexto

Esta seção descreve as principais tecnologias usadas neste documento:

XPK

O XPK é uma ferramenta que simplifica o provisionamento e o gerenciamento de clusters e cargas de trabalho do GKE, especialmente para tarefas de IA/ML. O XPK ajuda a gerar infraestrutura pré-configurada e otimizada para treinamento, o que o torna uma boa opção para provas de conceito e ambientes de teste.

É possível criar um cluster que usa TPUs com a Google Cloud CLI ou um kit de processamento acelerado (XPK).

  • Use a CLI gcloud para criar manualmente a instância do cluster do GKE para personalização precisa ou expansão de ambientes de produção do GKE atuais.
  • Use o XPK para criar rapidamente clusters do GKE e executar cargas de trabalho para prova de conceito e testes. Para mais informações, consulte o README do XPK.

Este documento usa o XPK exclusivamente para provisionar e gerenciar recursos.

Para mais informações, consulte a documentação do Accelerated Processing Kit (XPK).

Início flexível

Com o início flexível, é possível otimizar o provisionamento de TPU pagando apenas pelos recursos necessários. O início flexível é recomendado se a carga de trabalho exigir recursos provisionados dinamicamente conforme necessário, por até sete dias e acesso econômico.

Este documento usa o início flexível como exemplo de opção de consumo, mas também é possível usar outras opções, como reservas ou Spot. Para mais informações, consulte Sobre as opções de consumo de aceleradores para cargas de trabalho de IA/ML no GKE.

Managed Lustre

O Managed Lustre é um serviço de sistema de arquivos paralelo de alto desempenho projetado para cargas de trabalho exigentes. O driver CSI do Managed Lustre permite integrar instâncias do Managed Lustre ao GKE, usando reivindicações de volume persistente (PVCs) e volumes persistentes (PVs) padrão do Kubernetes. Esse driver é particularmente benéfico para cargas de trabalho de IA, ML e HPC que exigem armazenamento persistente, escalonável e de alta capacidade.

Para mais informações, consulte Sobre o driver CSI do Lustre gerenciado.

Antes de começar

Antes de começar, verifique se você realizou as tarefas a seguir:

  • Ative a API Google Cloud Managed Lustre e a API Google Kubernetes Engine.
    • Ativar APIs
  • Se você quiser usar a CLI do Google Cloud para essa tarefa, instale e inicialize a gcloud CLI. Se você instalou a gcloud CLI anteriormente, instale a versão mais recente executando o comando gcloud components update. Talvez as versões anteriores da gcloud CLI não sejam compatíveis com a execução dos comandos neste documento.

Preparar o ambiente

Nesta seção, mostramos como preparar o ambiente de cluster.

  1. Na nova janela de terminal, crie um ambiente virtual:

    VENV_DIR=~/venvp4;python3 -m venv $VENV_DIR;source $VENV_DIR/bin/activate

  2. Instale o XPK seguindo as etapas no arquivo de instalação do XPK. Use pip install em vez de clonar da origem.

  3. Defina as variáveis de ambiente padrão:

    gcloud config set project PROJECT_ID
gcloud config set billing/quota_project PROJECT_ID
export PROJECT_ID=$(gcloud config get project)
export LOCATION=LOCATION
export CLUSTER_NAME=CLUSTER_NAME
export GKE_VERSION=VERSION
export NETWORK_NAME=NETWORK_NAME
export IP_RANGE_NAME=IP_RANGE_NAME
export FIREWALL_RULE_NAME=FIREWALL_RULE_NAME
export ACCELERATOR_TYPE=v6e-16
export NUM_SLICES=1

    Substitua os seguintes valores:

    Os comandos anteriores configuram um tipo de acelerador v6e-16. Essa configuração inclui as seguintes variáveis:

    • ACCELERATOR_TYPE=v6e-16: corresponde à TPU Trillium com uma topologia 4x4. Essa versão da TPU instrui o GKE a provisionar um pool de nós de fração de vários hosts. O v6e-16 é mapeado para o tipo de máquina ct6e-standard-4t no GKE.
    • NUM_SLICES=1: o número de pools de nós de fração de TPU que o XPK cria para o ACCELERATOR_TYPE selecionado.

    Se quiser personalizar as variáveis ACCELERATOR_TYPE e NUM_SLICES, consulte os seguintes documentos para encontrar as combinações disponíveis:

    • Para identificar a versão da TPU, o tipo de máquina para GKE, a topologia e a zona disponível que você quer usar, consulte Planejar TPUs no GKE.
    • Para mapear o tipo de máquina do GKE com o tipo de acelerador na API Cloud TPU, consulte a documentação da TPU Trillium (v6e).

Preparar uma rede VPC

Prepare uma rede de nuvem privada virtual para sua instância gerenciada do Lustre e o cluster do GKE.

  1. Ative a API Service Networking:

    gcloud services enable servicenetworking.googleapis.com \
        --project=${PROJECT_ID}

  2. Crie uma rede VPC:

    gcloud compute networks create ${NETWORK_NAME} \
        --subnet-mode=auto --project=${PROJECT_ID} \
        --mtu=8896

  3. Crie um intervalo de endereços IP para o peering de VPC:

    gcloud compute addresses create ${IP_RANGE_NAME} \
        --global \
        --purpose=VPC_PEERING \
        --prefix-length=20 \
        --description="Managed Lustre VPC Peering" \
        --network=${NETWORK_NAME} \
        --project=${PROJECT_ID}

  4. Consiga o intervalo CIDR do intervalo de endereços IP:

    CIDR_RANGE=$(
    gcloud compute addresses describe ${IP_RANGE_NAME} \
            --global  \
            --format="value[separator=/](address, prefixLength)" \
            --project=${PROJECT_ID}
)

  5. Crie uma regra de firewall para permitir o tráfego TCP do intervalo de endereços IP:

    gcloud compute firewall-rules create ${FIREWALL_RULE_NAME} \
        --allow=tcp:988,tcp:6988 \
        --network=${NETWORK_NAME} \
        --source-ranges=${CIDR_RANGE} \
        --project=${PROJECT_ID}

  6. Conecte o peering de VPC.

    gcloud services vpc-peerings connect \
        --network=${NETWORK_NAME} \
        --project=${PROJECT_ID} \
        --ranges=${IP_RANGE_NAME} \
        --service=servicenetworking.googleapis.com

Criar uma instância de armazenamento do Managed Lustre

Crie uma instância de armazenamento do Managed Lustre.

  1. Defina variáveis de instância de armazenamento:

    export STORAGE_NAME=STORAGE_NAME
export STORAGE_THROUGHPUT=STORAGE_THROUGHPUT
export STORAGE_CAPACITY=STORAGE_CAPACITY_GIB
export STORAGE_FS=lfs

    Substitua os seguintes valores:

  2. Crie a instância do Managed Lustre:

    gcloud lustre instances create ${STORAGE_NAME} \
        --per-unit-storage-throughput=${STORAGE_THROUGHPUT} \
        --capacity-gib=${STORAGE_CAPACITY} \
        --filesystem=${STORAGE_FS} \
        --location=${LOCATION} \
        --network=projects/${PROJECT_ID}/global/networks/${NETWORK_NAME} \
        --project=${PROJECT_ID} \
        --async # Creates the instance asynchronously

    A flag --async cria a instância de forma assíncrona e fornece um ID de operação para acompanhar o status dela.

  3. Verifique o status da operação:

    gcloud lustre operations describe OPERATION_ID  \
        --location=${LOCATION} \
        --project=${PROJECT_ID}

    Substitua OPERATION_ID pelo ID da saída do comando assíncrono anterior. Se você não tiver o ID, liste todas as operações:

    gcloud lustre operations list \
        --location=${LOCATION} \
        --project=${PROJECT_ID}

    A instância estará pronta quando a resposta ao comando mostrar done: true.

Usar o XPK para criar um cluster do GKE

Use o XPK para criar um cluster do GKE com um pool de nós.

Crie um cluster do GKE:

xpk cluster create --cluster ${CLUSTER_NAME} \
        --num-slices=${NUM_SLICES} \
        --tpu-type=${ACCELERATOR_TYPE} \
        --zone=${LOCATION} \
        --project=${PROJECT_ID} \
        --gke-version=${GKE_VERSION} \
        --custom-cluster-arguments="--network=${NETWORK_NAME}" \
        --enable-lustre-csi-driver \
        --flex

Esse comando cria um cluster do GKE usando o XPK. O cluster está configurado para usar o flex-start no provisionamento de nós e tem o driver CSI do Lustre gerenciado ativado.

Anexar a instância de armazenamento ao cluster

Para configurar o PersistentVolume (PV) e o PersistentVolumeClaim (PVC), esta seção usa o comando de anexação de armazenamento XPK (xpk storage attach) com um arquivo de manifesto. Esta seção usa um manifesto de exemplo do código-fonte XPK.

Anexe a instância de armazenamento do Managed Lustre ao cluster do GKE seguindo estas etapas:

  1. Faça o download do arquivo de manifesto de exemplo no diretório de trabalho atual e salve-o como lustre-manifest-attach.yaml.

  2. Atualize o arquivo de manifesto com as informações da sua instância do Managed Lustre:

    1. Na seção PersistentVolume, substitua os seguintes valores:

      • STORAGE_SIZE: o tamanho da instância do Managed Lustre, em GiB.
      • PROJECT_ID/ZONE/INSTANCE_NAME: o caminho completo do recurso da sua instância do Managed Lustre.
      • IP_ADDRESS: o endereço IP da instância do Lustre gerenciado.
      • FILE_SYSTEM: o tipo de sistema de arquivos, que é lfs.

    2. Na seção PersistentVolumeClaim, substitua os seguintes valores:

      • STORAGE_SIZE: o tamanho do PersistentVolumeClaim, em GiB.

  3. Anexe a instância de armazenamento ao cluster:

    xpk storage attach ${STORAGE_NAME} \
        --cluster=${CLUSTER_NAME} --project=${PROJECT_ID} --zone=${LOCATION} \
        --type=lustre \
        --mount-point='/lustre-data' \
        --readonly=false \
        --auto-mount=true \
        --manifest='./lustre-manifest-attach.yaml'

  4. Verifique se você anexou o armazenamento ao cluster:

    xpk storage list \
        --cluster=${CLUSTER_NAME} --project=${PROJECT_ID} --zone=${LOCATION}

Executar uma carga de trabalho

Execute uma carga de trabalho com a instância do Managed Lustre anexada . O comando de exemplo a seguir lista os discos disponíveis e cria um arquivo "hello" no diretório da instância do Managed Lustre.

Crie e execute a carga de trabalho:

xpk workload create --workload test-lustre \
--cluster=${CLUSTER_NAME} --project=${PROJECT_ID} --zone=${LOCATION} \
--command="df -h && echo 'hello' > /lustre-data/hello.txt && cat /lustre-data/hello.txt" \
--tpu-type=${ACCELERATOR_TYPE} \
--num-slices=1 \
--flex

Limpar

Depois de concluir as etapas neste documento, exclua o cluster para evitar cobranças indesejadas na sua conta:

  xpk cluster delete --cluster ${CLUSTER_NAME} \
        --zone ${LOCATION} \
        --project ${PROJECT_ID}

A seguir