Contexto
Uma carga de trabalho em lote é um processo geralmente criado para ter um ponto de partida e de conclusão. Considere as cargas de trabalho em lote no GKE se a arquitetura envolver a ingestão, o processamento e a saída de dados em vez de usar dados brutos. Áreas como machine learning, inteligência artificial, e computação de alto desempenho (HPC) apresentam diferentes tipos de cargas de trabalho em lote, como treinamento de modelos off-line, previsão em lote, análise de dados, simulação de sistemas físicos e processamento de vídeo.
Ao projetar cargas de trabalho em lote em contêineres, é possível aproveitar os seguintes benefícios do GKE:
- Uma comunidade ampla, um padrão aberto e um serviço gerenciado.
- Eficiência de custos com orquestração efetiva de cargas de trabalho e infraestrutura e recursos computacionais especializados.
- Isolamento e portabilidade de contentorização, permitindo o uso da nuvem como capacidade excedente, mantendo a segurança dos dados.
- Disponibilidade da capacidade de burst, seguida pela redução rápida do escalonamento dos clusters do GKE.
Objetivos
Este tutorial é voltado a engenheiros de machine learning ou cientistas de dados que querem executar cargas de trabalho de machine learning em lote no GKE com a seguinte arquitetura econômica e escalonável:
Este tutorial inclui as etapas a seguir:
- Criar um cluster do GKE Autopilot. Como alternativa, é possível usar um cluster padrão do GKE neste tutorial.
- Criar um volume NFS do Filestore.
- Criar uma fila de jobs do Redis no cluster
- Transferir conjuntos de dados para o volume NFS e enfileirá-los para serem consumidos pela carga de trabalho.
- Executar uma carga de trabalho de machine learning em lote no cluster do GKE.
Custos
Neste documento, você usará os seguintes componentes faturáveis do Google Cloud:
Para gerar uma estimativa de custo baseada na projeção de uso deste tutorial, use a calculadora de preços.
Para seguir as instruções passo a passo desta tarefa diretamente no console do Google Cloud, clique em Orientação:
Antes de começar
- Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.
-
In the Google Cloud console, on the project selector page, select or create a Google Cloud project.
-
Verifique se a cobrança está ativada para o seu projeto do Google Cloud.
-
Enable the Compute Engine, GKE, and Filestore APIs.
-
In the Google Cloud console, on the project selector page, select or create a Google Cloud project.
-
Verifique se a cobrança está ativada para o seu projeto do Google Cloud.
-
Enable the Compute Engine, GKE, and Filestore APIs.
-
In the Google Cloud console, activate Cloud Shell.
At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.
Prepare o ambiente
Clone o repositório de amostra usado neste tutorial:
git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples cd kubernetes-engine-samples/batch/aiml-workloads
Crie um cluster do GKE Autopilot:
gcloud container clusters create-auto batch-aiml \ --region=us-central1
Essa etapa pode levar até cinco minutos para ser concluída.
Configurar o armazenamento de conjuntos de dados com um Network File System (NFS)
A carga de trabalho de machine learning requer uma solução de armazenamento para os conjuntos de dados e arquivos de saída. Nesta seção, você cria uma instância Filestore e fornece acesso a ela usando um PersistentVolume e um PersistentVolumeClaim
Para saber mais, confira como projetar uma estratégia de armazenamento ideal e como acessar instâncias do Filestore dos clusters do GKE.
Criar uma instância do Filestore
Criar uma instância do Filestore:
gcloud filestore instances create batch-aiml-filestore \ --zone=us-central1-b \ --tier=BASIC_HDD \ --file-share=name="NFSVol",capacity=1TB \ --network=name="default"
Este comando especifica as seguintes opções:
tier
: o nível de serviço da instância do Filestore. Esse exemplo usa o nível básico. Para saber mais sobre as outras opções, consulte Níveis de serviço.network=name
: o nome da rede de nuvem privada virtual (VPC) da instância do Filestore. O cluster do GKE precisa estar na mesma rede VPC que a instância do Filestore.capacity
: o tamanho desejado do volume. Especifique o valor de armazenamento em uma das unidades compatíveis descritas em Quantidades de recursos.
Verifique se a instância do Filestore foi implantada:
gcloud filestore instances list \ --project=PROJECT_ID \ --zone=us-central1-b
Substitua o
PROJECT_ID
pelo ID do projeto do Google Cloud.O resultado será assim:
INSTANCE_NAME: batch-aiml-filestore LOCATION: us-central1-b TIER: BASIC_HDD CAPACITY_GB: 1024 FILE_SHARE_NAME: NFSVol IP_ADDRESS: 203.0.113.54 STATE: READY CREATE_TIME: 2022-03-15T18:23:51
Anote o valor no campo
IP_ADDRESS
para usar na seção a seguir.
Criar um PersistentVolume
Uma especificação PersistentVolume do Kubernetes permite que o cluster do GKE se conecte à instância do Filestore.
Atualize o arquivo
kubernetes-manifests/persistent-volume.yaml
com o endereço IP da instância do Filestore:sed -i "\ s/<FILESTORE_IP_ADDRESS>/IP_ADDRESS/g" \ kubernetes-manifests/persistent-volume.yaml
Substitua
IP_ADDRESS
pelo endereço IP que você anotou ao criar a instância do Filestore na seção anterior.Implante o PersistentVolume:
kubectl apply -f kubernetes-manifests/persistent-volume.yaml
Criar um PersistentVolumeClaim
Um PersistentVolumeClaim do Kubernetes permite que os pods e jobs do Kubernetes acessem os recursos de armazenamento de um PersistentVolume.
Implante o PersistentVolumeClaim:
kubectl apply -f kubernetes-manifests/persistent-volume-claim.yaml
Consumir a PersistentVolumeClaim
Com o PersistentVolume e o PersistentVolumeClaim configurados no cluster do GKE, é possível configurar o servidor Redis e os jobs em lote para consumir o PersistentVolumeClaim. Isso aparece como um volume de armazenamento montável.
Inspecione os arquivos kubernetes-manifests/redis-pod.yaml
e kubernetes-manifests/workload.yaml
.
As configurações do manifesto são semelhantes às seguintes:
spec:
…
containers:
- name: workload
image: "us-central1-docker.pkg.dev/gke-batch-aiml/batch-aiml-docker-repo/workload"
volumeMounts:
- mountPath: /mnt/fileserver
name: workload-pvc
volumes:
- name: workload-pvc
persistentVolumeClaim:
claimName: fileserver-claim
readOnly: false
Nesse manifesto:
spec.volumes
especifica o PersistentVolumeClaim para consumo.spec.containers.volumeMounts
especifica o caminho do arquivo local em que o pod pode acessar o compartilhamento de arquivos do Filestore.
Configurar uma fila de jobs do Redis
A carga de trabalho processa dados em lotes para treinar iterativamente um modelo de detecção de fraudes. Para gerenciar os conjuntos de dados que estão sendo processados ou ainda na fila, implante o servidor Redis no cluster do GKE.
Para este tutorial, inicie uma única instância do Redis. Para implantar o Redis de maneira escalonável e redundante, consulte Criar um aplicativo da Web de várias camadas com Redis e PHP.
Implante a especificação do servidor do Redis.
kubectl apply -f kubernetes-manifests/redis-pod.yaml
Verifique se ele está em execução:
kubectl get pods
O resultado será assim:
NAME READY STATUS RESTARTS AGE redis-leader 1/1 Running 0 118s
O pod pode levar até dois minutos para começar a ser executado.
Transfira os arquivos que contêm os conjuntos de dados de treinamento e teste para o volume NFS.
sh scripts/transfer-datasets.sh
Esse script copia os arquivos do repositório de código de amostra para o diretório
/mnt/fileserver/datasets/
no podredis-leader
.Preencha a fila do Redis.
sh scripts/queue-jobs.sh
Esse script envia os caminhos de arquivo para os conjuntos de dados de treinamento a uma lista chamada
datasets
no banco de dados do Redis. Essa fila será usada pela carga de trabalho para localizar o próximo conjunto de dados a ser processado.Implante o Serviço para tornar o servidor Redis detectável no cluster do GKE.
kubectl apply -f ./kubernetes-manifests/redis-service.yaml
Executar a carga de trabalho em lote
Neste ponto, você preparou o cluster do GKE, a fila de jobs do Redis e o compartilhamento de arquivos. Agora, é possível executar sua carga de trabalho em lote.
Nesta seção, você usará uma imagem de contêiner de uma carga de trabalho de amostra para treinar um modelo de detecção de fraudes usando lotes de dados de transações financeiras. O processo de treinamento pode ser resumido da seguinte forma:
Um cliente Redis reivindica jobs (caminhos de arquivo para conjuntos de dados) na fila e os remove da fila depois de concluído.
Uma classe de gerenciador de treinamento de modelo,
FraudDetectionModelTrainer
, carrega um novo lote de dados e, opcionalmente, um estado salvo de um modelo de machine learning. O conjunto de dados é usado para refinar o modelo. Esse processo é conhecido como treinamento "inicialização com estado salvo".O novo estado do modelo e um relatório de detalhes do lote e pontuações de desempenho são salvos no volume NFS do Filestore, que pode ser acessado no cluster do GKE usando um PersistentVolumeClaim.
Para saber mais, conheça o código-fonte.
Definir o job
O manifesto a seguir descreve o job do Kubernetes da imagem da carga de trabalho em lote.
Implantar a carga de trabalho
Implante o job:
kubectl apply -f ./kubernetes-manifests/workload.yaml
Verifique se o status do pod
workload-XXX
éCompleted
.watch kubectl get pods
Isso pode demorar alguns segundos… Para voltar à linha de comando, pressione
Ctrl+C
.O resultado será assim:
NAME READY STATUS RESTARTS AGE redis-leader 1/1 Running 0 16m workload-4p55d 0/1 Completed 0 83s
Verifique os registros do job
workload
:kubectl logs job/workload
O resultado será assim:
Worker with sessionID: b50f9459-ce7f-4da8-9f84-0ab5c3233a72 Initial queue state: empty=False Processing dataset: datasets/training/2018-04-04.pkl Processing dataset: datasets/training/2018-04-03.pkl Processing dataset: datasets/training/2018-04-02.pkl Processing dataset: datasets/training/2018-04-01.pkl Queue empty, exiting
Os arquivos
.pkl
são serializações de conjuntos de dados que contêm um lote de transações de cartão de crédito, marcadas como válidas ou fraudulentas. O jobworkload
itera esses arquivos, descompactando os conjuntos de dados e usando-os para treinar o modelo de machine learning, antes de removê-los da fila do Redis. A carga de trabalho continua a processar os dados em lotes, até que a fila do Redis seja esvaziada, antes de sair com sucesso.
Analisar o volume NFS
Durante a operação, a carga de trabalho cria arquivos no volume NFS montado, acessível em todo o cluster a outros jobs em lote ou aplicativos on-line.
Liste os arquivos criados pela carga de trabalho:
kubectl exec --stdin --tty redis-leader -- /bin/sh -c "ls -1 /mnt/fileserver/output"
A saída será a seguinte:
model_cpt_2018-04-01.pkl model_cpt_2018-04-02.pkl model_cpt_2018-04-03.pkl model_cpt_2018-04-04.pkl report.txt
Os checkpoints do modelo treinado (nomes de arquivos como
model_cpt_XXX.pkl
) e um relatório do desempenho do modelo (report.txt
) foram criados no diretório/mnt/fileserver/output
no volume NFS.Inspecione o relatório de desempenho do modelo:
kubectl exec --stdin --tty redis-leader -- /bin/sh -c "cat /mnt/fileserver/output/report.txt"
Veja a seguir um trecho da resposta:
Report generated on: 2022-02-09 14:19:42.303619 Training dataset: 2018-04-04.pkl Model checkpoint: model_cpt_2018-04-04.pkl --- Accuracy on training data: 0.9981112277019937 Accuracy on testing data: 0.9977204434773599
O arquivo contém entradas detalhando o tempo de treinamento, o conjunto de dados usado, a precisão alcançada e o nome do arquivo do checkpoint do modelo associado ao treinamento.
Para saber mais sobre volumes NFS, confira os guias do Filestore.
Limpar
Para evitar cobranças na sua conta do Google Cloud pelos recursos usados no tutorial, exclua o projeto que os contém ou mantenha o projeto e exclua os recursos individuais.
Remover recursos individuais
Para remover os recursos individuais criados para este tutorial, execute os comandos a seguir.
Exclua o cluster:
gcloud container clusters delete batch-aiml \ --region=us-central1
Excluir a instância do Filestore:
gcloud filestore instances delete batch-aiml-filestore \ --zone=us-central1-b
Excluir o projeto
- In the Google Cloud console, go to the Manage resources page.
- In the project list, select the project that you want to delete, and then click Delete.
- In the dialog, type the project ID, and then click Shut down to delete the project.
A seguir
Consulte a documentação do GKE.
Conheça os Volumes permanentes em mais detalhes.
Saiba mais sobre Jobs no GKE.
Aprenda a usar VMs spot para executar cargas de trabalho tolerantes a falhas.
Explore outros tutoriais do Kubernetes Engine.
Confira arquiteturas de referência, diagramas, tutoriais e práticas recomendadas do Google Cloud. Confira o Centro de arquitetura do Cloud.