Transferir dados do Cloud Storage durante o provisionamento dinâmico usando o Volume Populator do GKE

O GKE Volume Populator permite pré-carregar dados de um armazenamento de origem para um PersistentVolumeClaim de destino durante o provisionamento dinâmico, sem executar scripts ou comandos da CLI adicionais para transferência manual de dados. Esse recurso automatiza e simplifica o processo de transferência de dados usando o recurso Kubernetes Volume Populator. Ela oferece portabilidade de dados perfeita para que você possa trocar os tipos de armazenamento e aproveitar as otimizações de preço ou desempenho.

Use esse recurso se precisar transferir grandes quantidades de dados de buckets do Cloud Storage para um PersistentVolumeClaim com suporte de outro tipo de armazenamento doGoogle Cloud (como Parallelstore).

Você interage principalmente com o GKE Volume Populator usando a CLI gcloud e a CLI kubectl. O GKE Volume Populator é compatível com clusters do Autopilot e Standard. Não é necessário ativar o GKE Volume Populator. Ele é um componente gerenciado do GKE ativado por padrão.

Vantagens

• Se você quiser aproveitar o desempenho de um sistema de arquivos paralelos gerenciado, mas seus dados estiverem armazenados no Cloud Storage, use o GKE Volume Populator para simplificar a transferência de dados.
• O GKE Volume Populator permite a portabilidade de dados. Você pode mover dados de acordo com suas necessidades.
• O GKE Volume Populator oferece suporte à autenticação baseada no IAM para que você possa transferir dados e manter o controle de acesso refinado.

O diagrama mostra como os dados fluem do armazenamento de origem para o de destino e a criação do PersistentVolume para o armazenamento de destino usando o GKE Volume Populator.

Limitações

• O GKE Volume Populator só é compatível com buckets do Cloud Storage como armazenamento de origem e instâncias do Parallelstore como tipo de armazenamento de destino.
• O recurso personalizado GCPDataSource precisa estar no mesmo namespace que sua carga de trabalho do Kubernetes. Volumes com fontes de dados entre namespaces não são compatíveis.
• O GKE Volume Populator só é compatível com a vinculação da Federação de Identidade da Carga de Trabalho para GKE de contas de serviço do IAM a uma conta de serviço do Kubernetes. Não é possível conceder permissões do IAM diretamente à conta de serviço do Kubernetes.

Antes de começar

Antes de começar, veja se você realizou as seguintes tarefas:

• Ative a API Parallelstore e a API Google Kubernetes Engine.
Ativar APIs
• Se você quiser usar a Google Cloud CLI para essa tarefa, instale e, em seguida, inicialize a CLI gcloud. Se você instalou a gcloud CLI anteriormente, instale a versão mais recente executando gcloud components update.

• Consulte a visão geral do driver CSI do Parallelstore para limitações e requisitos.
• Crie seus buckets do Cloud Storage, preenchidos com os dados que você quer transferir.

Requisitos

Para usar o GKE Volume Populator, os clusters precisam atender aos seguintes requisitos:

• Use a versão 1.31.1-gke.1729000 ou mais recente do cluster do GKE.
• Ter o driver CSI do Parallelstore ativado. O GKE ativa o driver CSI por padrão em clusters novos e atuais do GKE Autopilot. Em clusters Standard novos e atuais, é necessário ativar o driver CSI.

Preparar o ambiente

Esta seção aborda as etapas para criar clusters do GKE e definir as permissões necessárias para usar o GKE Volume Populator.

Configurar a rede VPC

Você precisa especificar a mesma rede de nuvem privada virtual (VPC) ao criar a instância do Parallelstore e as VMs do Compute Engine ou os clusters do GKE do cliente. Para permitir que a VPC se conecte de maneira particular aos serviços do Google Cloud sem expor o tráfego à Internet pública, faça uma configuração única de acesso a serviços particulares (PSA), se ainda não tiver feito isso.

Para configurar o PSA, siga estas etapas:

1. Para configurar o peering de rede no seu projeto, configure a permissão do IAM Administrador de rede do Compute (roles/compute.networkAdmin).

   Para conceder o papel, execute o seguinte comando:

   gcloud projects add-iam-policy-binding PROJECT_ID \
       --member="user:EMAIL_ADDRESS" \
       --role=roles/compute.networkAdmin
   

   Substitua EMAIL_ADDRESS pelo seu endereço de e-mail.

2. Ative o Service Networking:

   gcloud services enable servicenetworking.googleapis.com
   

3. Crie uma rede VPC:

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

   Substitua:

   • NETWORK_NAME: o nome da rede VPC em que você vai criar a instância do Parallelstore.
   • PROJECT_ID: o Google Cloud ID do projeto.

4. Crie um intervalo de IP.

   O Acesso privado a serviços exige um intervalo de endereços IP (bloco CIDR) com um comprimento de prefixo de pelo menos /24 (256 endereços). O Parallelstore reserva 64 endereços por instância, o que significa que você pode reutilizar esse intervalo de IP com outros serviços ou outras instâncias do Parallelstore, se necessário.

   gcloud compute addresses create IP_RANGE_NAME \
     --global \
     --purpose=VPC_PEERING \
     --prefix-length=24 \
     --description="Parallelstore VPC Peering" \
     --network=NETWORK_NAME \
     --project=PROJECT_ID
   

   Substitua IP_RANGE_NAME pelo nome do intervalo de endereços IP da rede VPC.

5. Defina uma variável de ambiente com o intervalo CIDR associado ao intervalo criado na etapa anterior:

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

6. Crie uma regra de firewall para permitir o tráfego TCP do intervalo de IP que você criou:

   gcloud compute firewall-rules create FIREWALL_NAME \
     --allow=tcp \
     --network=NETWORK_NAME \
     --source-ranges=$CIDR_RANGE \
     --project=PROJECT_ID
   

   Substitua FIREWALL_NAME pelo nome da regra de firewall para permitir o tráfego TCP do intervalo de IP que você criou.

7. Conecte o peering:

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

Se você tiver problemas ao configurar a rede VPC, consulte o guia de solução de problemas do Parallelstore.

Criar o cluster do GKE

Recomendamos que você use um cluster do Autopilot para ter uma experiência totalmente gerenciada do Kubernetes. Para escolher o modo de operação do GKE mais adequado para suas necessidades de carga de trabalho, consulte Escolher um modo de operação do GKE.

gcloud container clusters create-auto CLUSTER_NAME  \
    --network=NETWORK_NAME  \
    --cluster-version=CLUSTER_VERSION \
    --location=CLUSTER_LOCATION

gcloud container clusters create CLUSTER_NAME \
    --addons=ParallelstoreCsiDriver \
    --cluster-version=CLUSTER_VERSION \
    --workload-pool=PROJECT_ID.svc.id.goog \
    --network=NETWORK_NAME \
    --location=CLUSTER_LOCATION

Configurar as permissões necessárias

Para transferir dados de um bucket do Cloud Storage, configure permissões para a federação de identidade da carga de trabalho para o GKE.

1. Crie um namespace do Kubernetes:

   kubectl create namespace NAMESPACE
   

   Substitua NAMESPACE pelo namespace em que suas cargas de trabalho serão executadas.

2. Crie uma conta de serviço do Kubernetes.

   kubectl create serviceaccount KSA_NAME \
       --namespace=NAMESPACE
   

   Substitua KSA_NAME pelo nome da conta de serviço do Kubernetes que seu pod usa para autenticar nas APIs Google Cloud .

3. Crie uma conta de serviço do IAM. Também é possível usar qualquer conta de serviço do IAM atual em qualquer projeto da organização:

   gcloud iam service-accounts create IAM_SA_NAME \
       --project=PROJECT_ID
   

   Substitua:

   • IAM_SA_NAME: o nome da sua conta de serviço do IAM.
   • PROJECT_ID: o Google Cloud ID do projeto.

4. Conceda à sua conta de serviço do IAM o papel roles/storage.objectViewer para que ela possa acessar seu bucket do Cloud Storage:

   gcloud storage buckets \
       add-iam-policy-binding gs://GCS_BUCKET \
       --member "serviceAccount:IAM_SA_NAME@PROJECT_ID.iam.gserviceaccount.com" \
       --role "roles/storage.objectViewer"
   

   Substitua GCS_BUCKET pelo nome do seu bucket do Cloud Storage.

5. Crie a política de permissão do IAM que concede à conta de serviço do Kubernetes acesso para personificar a conta de serviço do IAM:

   gcloud iam service-accounts \
       add-iam-policy-binding IAM_SA_NAME@PROJECT_ID.iam.gserviceaccount.com \
       --role roles/iam.workloadIdentityUser \
       --member "serviceAccount:PROJECT_ID.svc.id.goog[NAMESPACE/KSA_NAME]"
   

6. Anote a conta de serviço do Kubernetes para que o GKE veja o link entre as contas de serviço.

   kubectl annotate serviceaccount KSA_NAME \
       --namespace NAMESPACE \
       iam.gke.io/gcp-service-account=IAM_SA_NAME@PROJECT_ID.iam.gserviceaccount.com
   

7. Crie a identidade do serviço Parallelstore:

   gcloud beta services identity create \
       --service=parallelstore.googleapis.com \
       --project=PROJECT_ID
   

8. Para permitir que a identidade de serviço do Parallelstore represente a conta de serviço do IAM, conceda o papel roles/iam.serviceAccountTokenCreator à identidade de serviço do Parallelstore. Defina a variável de ambiente PROJECT_NUMBER para usar nas etapas subsequentes.

   export PROJECT_NUMBER=$(gcloud projects describe PROJECT_ID --format="value(projectNumber)")
   gcloud iam service-accounts \
       add-iam-policy-binding "IAM_SA_NAME@PROJECT_ID.iam.gserviceaccount.com" \
       --member=serviceAccount:"service-${PROJECT_NUMBER?}@gcp-sa-parallelstore.iam.gserviceaccount.com" \
       --role=roles/iam.serviceAccountTokenCreator
   

   O valor PROJECT_NUMBER é o identificador exclusivo gerado automaticamente para seu projeto. Para encontrar esse valor, consulte Como criar e gerenciar projetos.

9. Para permitir que a identidade de serviço do Parallelstore acesse todos os recursos que a conta de serviço do IAM pode acessar, conceda o papel roles/iam.serviceAccountUser à identidade de serviço do Parallelstore:

   gcloud iam service-accounts \
       add-iam-policy-binding "IAM_SA_NAME@PROJECT_ID.iam.gserviceaccount.com" \
       --member=serviceAccount:"service-${PROJECT_NUMBER?}@gcp-sa-parallelstore.iam.gserviceaccount.com" \
       --role=roles/iam.serviceAccountUser
   

10. Para permitir que a identidade de serviço do GKE acesse todos os recursos que a conta de serviço do IAM pode acessar, conceda a função roles/iam.serviceAccountUser à identidade de serviço do GKE. Essa etapa não é necessária se o cluster do GKE e a conta de serviço do IAM estiverem no mesmo projeto.

    gcloud iam service-accounts \
        add-iam-policy-binding "IAM_SA_NAME@PROJECT_ID.iam.gserviceaccount.com" \
        --member=serviceAccount:"service-${PROJECT_NUMBER?}@container-engine-robot.iam.gserviceaccount.com" \
        --role=roles/iam.serviceAccountUser
    

Criar um volume do Parallelstore com dados pré-carregados

As seções a seguir descrevem o processo típico de criação de um volume do Parallelstore com dados pré-carregados de um bucket do Cloud Storage usando o GKE Volume Populator.

1. Crie um recurso GCPDataSource.
2. Crie um StorageClass do Parallelstore.
3. Crie um PersistentVolumeClaim para acessar o volume.
4. (Opcional) Veja o andamento da transferência de dados.
5. Criar uma carga de trabalho que consuma o volume.

Criar um recurso GCPDataSource

Para usar o GKE Volume Populator, crie um recurso personalizado GCPDataSource. Esse recurso define as propriedades de armazenamento de origem a serem usadas para o preenchimento de volume.

1. Salve o manifesto em um arquivo chamado gcpdatasource.yaml.

   apiVersion: datalayer.gke.io/v1
   kind: GCPDataSource
   metadata:
     name: GCP_DATA_SOURCE
     namespace: NAMESPACE
   spec:
     cloudStorage:
       serviceAccountName: KSA_NAME
       uri: gs://GCS_BUCKET/
   

   Substitua os seguintes valores:

   • GCP_DATA_SOURCE: o nome do CRD GCPDataSource que contém uma referência ao bucket do Cloud Storage. Consulte a referência de CRD GCPDataSource para mais detalhes.
   • NAMESPACE: o namespace em que suas cargas de trabalho serão executadas. O valor do namespace precisa ser igual ao namespace da carga de trabalho.
   • KSA_NAME: o nome da conta de serviço do Kubernetes que seu pod usa para autenticar nas APIs do Google Cloud . O valor de cloudStorage.serviceAccountName precisa ser a conta de serviço do Kubernetes configurada para a Federação de Identidade da Carga de Trabalho para GKE na etapa Configurar as permissões necessárias.
   • GCS_BUCKET: seu nome do bucket do Cloud Storage Como alternativa, você também pode especificar gs://GCS_BUCKET/PATH_INSIDE_BUCKET/ para o campo uri.

2. Crie o recurso GCPDataSource executando este comando:

   kubectl apply -f gcpdatasource.yaml
   

Criar um StorageClass do Parallelstore

Crie um StorageClass para direcionar o driver CSI do Parallelstore a provisionar instâncias do Parallelstore na mesma região do cluster do GKE. Isso ajuda a garantir a performance ideal de E/S.

1. Salve o seguinte manifesto parallelstore-class.yaml como :

   apiVersion: storage.k8s.io/v1
   kind: StorageClass
   metadata:
     name: parallelstore-class
   provisioner: parallelstore.csi.storage.gke.io
   volumeBindingMode: Immediate
   reclaimPolicy: Delete
   

2. Crie o StorageClass executando este comando:

   kubectl apply -f parallelstore-class.yaml
   

Se quiser criar um StorageClass personalizado com uma topologia específica, consulte o guia do CSI Parallelstore.

Criar um PersistentVolumeClaim para acessar o volume

O arquivo de manifesto a seguir mostra um exemplo de como criar um PersistentVolumeClaim no ReadWriteMany modo de acesso que faz referência ao StorageClass criado anteriormente.

1. Salve o manifesto em um arquivo chamado volume-populator-pvc.yaml.

   apiVersion: v1
   kind: PersistentVolumeClaim
   metadata:
     name: PVC_NAME
     namespace: NAMESPACE
   spec:
     accessModes:
     -   ReadWriteMany
     storageClassName: parallelstore-class
     resources:
       requests:
         storage: 12Gi
     dataSourceRef:
       apiGroup: datalayer.gke.io
       kind: GCPDataSource
       name: GCP_DATA_SOURCE
   

   Substitua os seguintes valores:

   • PVC_NAME: o nome do PersistentVolumeClaim em que você quer transferir seus dados. O PersistentVolumeClaim precisa ser compatível com uma instância do Parallelstore.
   • NAMESPACE: o namespace em que as cargas de trabalho serão executadas. O valor do namespace precisa ser igual ao namespace da sua carga de trabalho.
   • GCP_DATA_SOURCE: o nome do CRD GCPDataSource que contém uma referência ao bucket do Cloud Storage. Para mais detalhes, consulte a referência de CRD GCPDataSource.

2. Crie o PersistentVolumeClaim executando o seguinte comando:

   kubectl apply -f volume-populator-pvc.yaml
   

O GKE não vai programar o pod da carga de trabalho até que o provisionamento do PersistentVolumeClaim seja concluído. Para verificar o andamento da transferência de dados, consulte Ver o andamento da transferência de dados. Se você encontrar erros durante o provisionamento, consulte Solução de problemas.

(Opcional) Conferir o progresso da transferência de dados

Nesta seção, mostramos como acompanhar o progresso das transferências de dados de um bucket do Cloud Storage para um volume do Parallelstore. Você pode fazer isso para monitorar o status da transferência e garantir que seus dados sejam copiados com sucesso. Execute também esse comando se a operação de vinculação do PersistentVolumeClaim estiver demorando muito.

1. Para verificar o status do PersistentVolumeClaim, execute o seguinte comando:

   kubectl describe pvc PVC_NAME -n NAMESPACE
   

2. Verifique a mensagem de eventos do PersistentVolumeClaim para encontrar o progresso da transferência de dados. O GKE registra as mensagens aproximadamente uma vez por minuto. A resposta será semelhante a:

   Reason                          Message
   ------                          -------
   PopulateOperationStartSuccess   Populate operation started
   PopulateOperationStartSuccess   Populate operation started
   Provisioning                    External provisioner is provisioning volume for claim "my-namespace/my-pvc"
   Provisioning                    Assuming an external populator will provision the volume
   ExternalProvisioning            Waiting for a volume to be created either by the external provisioner 'parallelstore.csi.storage.gke.io' or manually by the system administrator. If volume creation is delayed, please verify that the provisioner is running and correctly registered.
   PopulateOperationStartSuccess   Populate operation started
   PopulatorPVCCreationProgress    objects found 7, objects copied 7, objects skipped 0. bytes found 1000020010, bytes copied 1000020010, bytes skipped 0
   PopulateOperationFinished       Populate operation finished
   PopulatorFinished               Populator finished
   

A operação de preenchimento pode levar algum tempo para começar e depende do tamanho do arquivo. Se você não notar nenhum progresso na transferência de dados depois de vários minutos, consulte a seção Solução de problemas.

Criar uma carga de trabalho que consuma o volume

Esta seção mostra um exemplo de como criar um pod que consome o recurso PersistentVolumeClaim criado anteriormente.

1. Salve o seguinte manifesto YAML para seu pod como pod.yaml.

   apiVersion: v1
   kind: Pod
   metadata:
     name: POD_NAME
     namespace: NAMESPACE
   spec:
     volumes:
     -   name: parallelstore-volume
       persistentVolumeClaim:
         claimName: PVC_NAME
     containers:
     -   image: nginx
       name: nginx
       volumeMounts:
       -   name: parallelstore-volume
         mountPath: /mnt/data
   

   Substitua os seguintes valores:

   • POD_NAME: o nome do pod que executa sua carga de trabalho.
   • NAMESPACE: o namespace em que as cargas de trabalho serão executadas. O valor do namespace precisa ser igual ao namespace da sua carga de trabalho.
   • PVC_NAME: o nome do PersistentVolumeClaim em que você quer transferir seus dados. O PersistentVolumeClaim precisa ser compatível com uma instância do Parallelstore.

2. Execute o comando a seguir para aplicar o manifesto ao cluster:

   kubectl apply -f pod.yaml
   

3. Verifique o status do pod e aguarde até que ele seja RUNNING. Seu PersistentVolumeClaim precisa ser vinculado antes que a carga de trabalho possa ser executada.

   kubectl describe pod POD_NAME -n NAMESPACE
   

4. Verifique se os arquivos foram transferidos e podem ser acessados pela carga de trabalho.

   kubectl exec -it POD_NAME -n NAMESPACE -c nginx -- /bin/sh
   

   Mude para o diretório /mnt/data e execute ls:

   cd /mnt/data
   ls
   

   A saída precisa listar todos os arquivos que existem no URI do bucket do Cloud Storage.

Excluir um PersistentVolumeClaim durante o provisionamento dinâmico

Se você precisar excluir seu PersistentVolumeClaim enquanto os dados ainda estão sendo transferidos durante o provisionamento dinâmico, terá duas opções: exclusão normal e exclusão forçada.

A exclusão normal exige menos esforço, mas pode levar mais tempo e não considera a configuração incorreta do usuário que impede a conclusão da transferência de dados. A exclusão forçada oferece uma alternativa mais rápida que permite maior flexibilidade e controle. Essa opção é adequada quando você precisa reiniciar rapidamente ou corrigir configurações incorretas.

Solução de problemas

Nesta seção, mostramos como resolver problemas relacionados ao GKE Volume Populator.

Antes de continuar, execute o comando a seguir para verificar se há avisos de eventos do PersistentVolumeClaim:

kubectl describe pvc PVC_NAME -n NAMESPACE

Erro: An internal error has occurred

Se você encontrar o seguinte erro, isso indica que ocorreu um erro interno da API Parallelstore.

Warning  PopulateOperationStartError  gkevolumepopulator-populator  Failed to start populate operation: populate data for PVC "xxx". Import data failed, error: rpc error: code = Internal desc = An internal error has occurred ("xxx")

Para resolver esse problema, siga estas etapas para coletar dados para o suporte:

1. Execute os comandos a seguir para receber o nome do PersistentVolumeClaim temporário, substituindo os marcadores de posição pelos nomes reais:

   PVC_UID=$(kubectl get pvc PVC_NAME -n NAMESPACE -o yaml | grep uid | awk '{print $2}')
   
   TEMP_PVC=prime-${PVC_UID?}
   
   echo ${TEMP_PVC?}
   

2. Execute o comando a seguir para conferir o nome do volume:

   PV_NAME=$(kubectl describe pvc ${TEMP_PVC?} -n gke-managed-volumepopulator | grep "Volume:" | awk '{print $2}')
   

3. Entre em contato com a equipe de suporte e informe a mensagem de erro, o nome do projeto e o nome do volume.

Problemas de permissão

Se você encontrar erros como os seguintes durante o preenchimento do volume, isso indica que o GKE encontrou um problema de permissões:

• O bucket do Cloud Storage não existe: PopulateOperationStartError com code = PermissionDenied
• Permissões ausentes no bucket do Cloud Storage ou nas contas de serviço: PopulateOperationFailed com "code: "xxx" message:"Verify if bucket "xxx" exists and grant access".
• Conta de serviço não encontrada: PopulateOperationStartError com code = Unauthenticated.

Para resolver esses erros, verifique o seguinte:

• Acesso ao bucket do Cloud Storage: verifique se o bucket existe e se a conta de serviço tem a função roles/storage.objectViewer permission.
• Contas de serviço: confirme se as contas de serviço do Kubernetes e do IAM existem e estão vinculadas corretamente.
• Conta de serviço do Parallelstore: verifique se a conta de serviço do Parallelstore existe e tem as permissões necessárias (roles/iam.serviceAccountTokenCreator e roles/iam.serviceAccountUser na conta do IAM).

Para ver etapas detalhadas e comandos de verificação, consulte Configurar as permissões necessárias. Se os erros persistirem, entre em contato com o suporte e informe a mensagem de erro, o nome do projeto e o nome do bucket do Cloud Storage.

Erros de argumento inválido

Se você encontrar erros de InvalidArgument, isso significa que provavelmente forneceu valores incorretos em GCPDataSource ou PersistentVolumeClaim. O registro de erros vai indicar os campos exatos que contêm os dados inválidos. Verifique se o URI do bucket do Cloud Storage e outros campos relevantes estão corretos.

Verifique se o provisionamento do PersistentVolumeClaim foi concluído

O GKE Volume Populator usa um PersistentVolumeClaim temporário no namespace gke-managed-volumepopulator para provisionamento de volume.

O PersistentVolumeClaim temporário é essencialmente um snapshot do seu PersistentVolumeClaim que ainda está em trânsito (aguardando o carregamento completo dos dados). O nome dele tem o formato prime-YOUR_PVC_UID.

Para verificar o status:

1. Execute os comandos a seguir:

   PVC_UID=$(kubectl get pvc PVC_NAME -n NAMESPACE -o yaml | grep uid | awk '{print $2}')
   
   TEMP_PVC=prime-$PVC_UID
   
   echo $TEMP_PVC
   
   kubectl describe pvc ${TEMP_PVC?} -n gke-managed-volumepopulator
   

   Se a saída estiver vazia, isso significa que o PersistentVolumeClaim temporário não foi criado. Execute o comando a seguir para verificar avisos de eventos do PersistentVolumeClaim:

   kubectl describe pvc PVC_NAME -n NAMESPACE
   

   Se o provisionamento for bem-sucedido, a saída será semelhante a esta: Procure o registro ProvisioningSucceeded:

   Warning  ProvisioningFailed     9m12s                   parallelstore.csi.storage.gke.io_gke-10fedd76bae2494db688-2237-793f-vm_5f284e53-b25c-46bb-b231-49e894cbba6c  failed to provision volume with StorageClass "parallelstore-class": rpc error: code = DeadlineExceeded desc = context deadline exceeded
   Warning  ProvisioningFailed     3m41s (x11 over 9m11s)  parallelstore.csi.storage.gke.io_gke-10fedd76bae2494db688-2237-793f-vm_5f284e53-b25c-46bb-b231-49e894cbba6c  failed to provision volume with StorageClass "parallelstore-class": rpc error: code = DeadlineExceeded desc = Volume pvc-808e41a4-b688-4afe-9131-162fe5d672ec not ready, current state: CREATING
   Normal   ExternalProvisioning   3m10s (x43 over 13m)    persistentvolume-controller                                                                                  Waiting for a volume to be created either by the external provisioner 'parallelstore.csi.storage.gke.io' or manually by the system administrator. If volume creation is delayed, please verify that the provisioner is running and correctly registered.
   Normal  Provisioning  8s (x13 over 10m)  "xxx"  External provisioner is provisioning volume for claim "xxx"
   Normal  ProvisioningSucceeded  7s  "xxx"  Successfully provisioned volume "xxx"
   

2. Verifique se a criação da instância do Parallelstore foi iniciada.

   gcloud beta parallelstore instances list \
       --project=PROJECT_ID \
       --location=-
   

   A resposta será semelhante a esta: Verifique se o volume está no estado CREATING. Quando a criação da instância do Parallelstore for concluída, o estado mudará para ACTIVE.

   "projects/PROJECT_ID/locations/<my-location>/<my-volume>"  12000  2024-10-09T17:59:42.582857261Z  2024-10-09T17:59:42.582857261Z  CREATING  projects/PROJECT_ID/global/NETWORK_NAME
   

Se o provisionamento falhar, consulte o guia de solução de problemas do Parallelstore para mais orientações.

A seguir

• Confira a documentação de referência do CSI do Parallelstore.
• Aprenda a usar a biblioteca de interceptação do Parallelstore para melhorar a performance da carga de trabalho.
• Teste o tutorial para treinar um modelo do TensorFlow com o Keras no GKE.