Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

Usar o particionamento dinâmico com um programador personalizado

Standard

Este documento descreve como usar o segmentação dinâmica interagindo diretamente com Recursos personalizados de segmentação. É possível criar intervalos, monitorar estados de partição e verificar a integridade dos intervalos.

Antes de seguir estas instruções, entenda os conceitos de segmentação dinâmica.

Por que usar o corte dinâmico com um programador personalizado?

Use seu próprio programador para gerenciar recursos personalizados Slice se você tiver requisitos de programação complexos ou quiser integrar o particionamento dinâmico à sua infraestrutura de programação atual.

Se você preferir usar um programador em vez de gerenciar recursos personalizados Slice diretamente, o GKE oferece integração com o Kueue e o agendamento com reconhecimento de topologia (TAS, na sigla em inglês). Para mais informações, consulte Programar intervalos dinâmicos com o Kueue e o TAS.

Visão geral do fluxo de trabalho

Para usar o corte dinâmico com um programador personalizado, faça as seguintes tarefas neste documento:

Ative o controlador de segmentação.
Criar pools de nós com provisionamento incremental.
Crie recursos personalizados de fração com base nos requisitos da sua carga de trabalho. Aplique o recurso personalizado Slice ao cluster.
Monitore os estados de partição e a integridade da fração.
Exclua o corte quando terminar.

Para mais informações sobre os campos e o status do recurso personalizado "Slice", consulte as informações de referência do recurso personalizado "Slice".

Requisitos

Para usar o particionamento dinâmico no GKE, você precisa atender aos seguintes requisitos:

Use um cluster Standard na versão 1.35.2-gke.1842000 ou mais recente, no canal rápido.
Use a versão Ironwood (TPU7x).
Use a imagem do Container-Optimized OS para seus nós.
Para usar o provisionamento incremental, use reservas no modo Toda a capacidade. O modo de capacidade é um recurso ativado pelo TPU Cluster Director.

Antes de começar

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

Ative a API Google Kubernetes Engine.

Ativar a API Google Kubernetes Engine

Se você quiser usar a Google Cloud CLI para essa tarefa, instale e, em seguida, inicialize a CLI gcloud. Se você instalou a CLI gcloud anteriormente, instale a versão mais recente executando o comando gcloud components update. Talvez as versões anteriores da CLI gcloud não sejam compatíveis com a execução dos comandos neste documento.
Observação:em instalações prévias da CLI gcloud, defina a propriedade compute/region. Se você usa principalmente clusters zonais, defina compute/zone. Ao definir um local padrão, é possível evitar erros na CLI gcloud como: One of [--zone, --region] must be supplied: Please specify location. Talvez seja necessário especificar o local em determinados comandos se o local do cluster for diferente do padrão definido.

Verifique se você tem um cluster Standard na versão 1.35.2-gke.1842000 ou mais recente no canal rápido. Para criar um novo cluster, consulte Como criar um cluster regional.
Verifique se você tem cota suficiente para o Ironwood (TPU7x) na sua região.
Se você planeja executar cargas de trabalho multislice, instale o JobSet v0.10.1 ou mais recente.
Solicite capacidade de TPU no modo "Toda a capacidade".

Ativar o controlador de fração

Para usar o corte dinâmico, ative o controlador de corte no cluster.

Atualize o cluster:

gcloud container clusters update CLUSTER_NAME \
    --location=LOCATION \
    --enable-slice-controller

Substitua:

CLUSTER_NAME: o nome do cluster.
LOCATION: a região com sua capacidade de TPU disponível.

Receba as credenciais para se comunicar com o cluster usando comandos kubectl:

gcloud config set container/cluster CLUSTER_NAME
gcloud container clusters get-credentials CLUSTER_NAME \
    --location=LOCATION

Na saída do comando a seguir, verifique se o valor slices.accelerator.gke.io está presente:
```
kubectl get crd slices.accelerator.gke.io
```
O resultado será o seguinte:
```
slices.accelerator.gke.io                2026-01-09T23:58:02Z
```

Criar pools de nós com provisionamento incremental

Nesta seção, descrevemos como criar pools de nós de TPU com provisionamento incremental. O GKE converte toda a capacidade de TPU em pools de nós de um grupo de 16 nós de VMs de TPU ou subblocos. O GKE provisiona esses pools de nós mesmo quando não consegue encontrar todas as 16 VMs íntegras. Para isso, ele coloca nós em partes íntegras da máquina host e provisiona incrementalmente máquinas não íntegras enquanto elas são reparadas.

É possível segmentar seu pool de nós para que ele pertença a qualquer um dos seguintes elementos:

Um bloco específico de TPUs, que é exposto em reservas no modo "Toda a capacidade". O bloqueio de segmentação permite que o GKE crie o pool de nós em qualquer sub-bloco disponível dentro do bloco especificado.
Um sub-bloco específico ou um grupo específico de 16 nós de VMs de TPU para um controle mais granular.

Criar uma política de carga de trabalho

Para criar um pool de nós de fração de TPU com Ironwood (TPU7x), primeiro crie uma política de carga de trabalho com o campo accelerator-topology-mode definido como provision_only. Essa configuração aciona o processo de provisionamento incremental.

Crie uma política de carga de trabalho:

gcloud compute resource-policies create workload-policy WORKLOAD_POLICY_NAME \
        --project=PROJECT_ID \
        --region=REGION  \
        --type=HIGH_THROUGHPUT \
        --accelerator-topology=4x4x4 \
        --accelerator-topology-mode=provision_only

Substitua:

WORKLOAD_POLICY_NAME: um nome para a política de carga de trabalho.
PROJECT_ID: o ID do projeto Google Cloud .
REGION: a região da política de carga de trabalho.

Neste comando, faça o seguinte:

Sempre defina o campo accelerator-topology como 4x4x4 para corresponder ao número total de chips em um único subbloco.
Sempre defina o campo accelerator-topology-mode como provision_only para garantir que o processo de provisionamento incremental seja acionado. Quando o campo provision_only é definido, o pool de nós provisiona nós de TPU sem formar links do ICI ou do OCS.

Faça com que seu pool de nós pertença a um bloco ou sub-bloco

É possível segmentar sub-blocos ou blocos específicos na sua reserva do modo "Toda a capacidade".

Segmentar um bloco:cada pool de nós usa a capacidade de um bloco especificado. O GKE coloca o pool de nós em um subbloco disponível nesse bloco. Você precisa criar tantos pools de nós quanto sub-blocos houver no bloco que você quer usar.
Segmentar um subbloco:cada pool de nós é mapeado para um subbloco específico e disponível. Ao usar o direcionamento por sub-bloco, o GKE cria o pool de nós se pelo menos uma VM estiver íntegra. O provisionamento incremental ajuda a garantir que todos os nós sejam colocados no sub-bloco especificado.

Bloquear

Para recuperar o nome do bloco em uma reserva e a contagem de sub-blocos disponíveis no bloco, siga estas etapas no documento Ver a topologia e o status de integridade de todas as reservas no modo de capacidade:
1. Identifique o nome do bloco listando todos os blocos de reserva e copiando o valor no campo name:. Esse valor é o nome do bloco ou BLOCK_NAME neste documento.
2. Determine quantos pools de nós criar descrevendo um bloco de reserva e identificando o valor no campo reservationSubBlockCount. Esse valor é o número de sub-blocos disponíveis. Por exemplo, o valor reservationSubBlockCount: 4 indica que o bloco tem quatro sub-blocos disponíveis, e você precisa criar quatro pools de nós separados.
Defina o caminho da reserva:
```
export RESERVATION_PATH="projects/PROJECT_ID/reservations/RESERVATION_NAME/reservationBlocks/BLOCK_NAME"
```
Substitua:
- RESERVATION_NAME: o nome da sua reserva de TPU.
- BLOCK_NAME: o nome do bloco.
Crie um pool de nós para cada sub-bloco identificado na etapa anterior. Por exemplo, se a contagem for 4, execute esse comando quatro vezes. Use um nome exclusivo para cada pool de nós.
```
gcloud container node-pools create NODE_POOL_NAME \
      --cluster=CLUSTER_NAME \
      --node-locations=ZONE \
      --machine-type=tpu7x-standard-4t \
      --num-nodes=16 \
      --placement-policy=WORKLOAD_POLICY_NAME \
      --reservation-affinity=specific \
      --reservation=${RESERVATION_PATH}
```
Substitua:
- NODE_POOL_NAME: o nome do novo pool de nós.
- CLUSTER_NAME: o nome do cluster do GKE.
- WORKLOAD_POLICY_NAME: o nome da política de carga de trabalho que você criou.
- ZONE: a zona do pool de nós, por exemplo, us-central1-a.

Sub-bloco

Para recuperar o nome do bloco e os IDs dos sub-blocos disponíveis, siga estas etapas no documento Ver a topologia e o status de integridade de todas as reservas do modo de capacidade:
1. Para identificar o nome do bloco, liste todos os blocos de reserva e copie o valor no campo name:. Esse valor é o nome do bloco ou BLOCK_NAME neste documento.
2. Para identificar o nome dos sub-blocos, liste todos os sub-blocos de um bloco e copie o valor no campo name: para cada entrada em reservationSubBlocks. Esse valor é o nome do sub-bloco ou SUBBLOCK_NAME neste documento.
Defina o caminho da reserva:
```
export RESERVATION_PATH="projects/PROJECT_ID/reservations/RESERVATION_NAME/reservationBlocks/BLOCK_NAME/reservationSubBlocks/SUBBLOCK_NAME"
```
Substitua:
- RESERVATION_NAME: o nome da sua reserva de TPU.
- BLOCK_NAME: o nome do bloco.
- SUBBLOCK_NAME: o nome do sub-bloco.

Crie o pool de nós:

gcloud container node-pools create NODE_POOL_NAME \
        --project=PROJECT_ID \
        --cluster=CLUSTER_NAME \
        --node-locations=ZONE \
        --machine-type=tpu7x-standard-4t \
        --num-nodes=16 \
        --placement-policy=WORKLOAD_POLICY_NAME \
        --reservation-affinity=specific \
        --reservation=${RESERVATION_PATH}

Substitua:

NODE_POOL_NAME: um nome exclusivo para o novo pool de nós, por exemplo, sub-block-pool-1.
PROJECT_ID: o ID do projeto Google Cloud .
CLUSTER_NAME: o nome do cluster do GKE.
ZONE: a zona do pool de nós, por exemplo, us-central2-b.
WORKLOAD_POLICY_NAME: o nome da política de carga de trabalho que você criou.

Nessa etapa, os nós são criados, mas os links de interconexão entre chips (ICI) ainda não estão ativos. Portanto, não é possível executar cargas de trabalho diretamente nesses pools de nós.

Para ativar todos os links do ICI necessários para formar a fração e permitir que as cargas de trabalho sejam programadas, crie uma fração dinâmica usando um dos seguintes métodos:

Crie um recurso personalizado de fração. Em vez de pods, use um recurso personalizado de Slice para definir a topologia especificada, que o controlador de fração ativa.
Agende cargas de trabalho do GKE com o Kueue e o TAS. O Kueue processa automaticamente a criação e exclusão de recursos personalizados Slice. Evite modificar manualmente os recursos personalizados Slice criados pelo Kueue.

Formar uma fração dinâmica

Depois de criar os pools de nós, é possível formar uma fatia dinâmica maior criando um recurso personalizado Slice. Em vez de pods, você usa um recurso personalizado de Slice para definir a topologia especificada, que o controlador de fração ativa.

Verificar o status dos nós e das partições

Para receber os nomes dos nós do pool de nós, execute o comando a seguir:

kubectl get nodes -l cloud.google.com/gke-nodepool=${NODE_POOL_NAME}

O resultado será assim:

NAME                                 STATUS   ROLES    AGE    VERSION
gke-np-status-update-7b4c890c-0jhp   Ready    <none>   2d1h   v1.35.1-gke.1396002
gke-np-status-update-7b4c890c-377r   Ready    <none>   2d1h   v1.35.1-gke.1396002
gke-np-status-update-7b4c890c-gb51   Ready    <none>   2d1h   v1.35.1-gke.1396002

Verifique o modelo de provisionamento do nó:
```
kubectl describe node NODE_NAME | grep "cloud.google.com/gke-accelerator-topology-mode"
```
O resultado será assim:
```
cloud.google.com/gke-accelerator-topology-mode: PROVISION_ONLY
```
Esse valor corresponde à configuração accelerator-topology-mode=provision_only definida quando você criou a política de carga de trabalho.
Recupere as informações do rótulo do nó:
```
kubectl describe node NODE_NAME | grep "cloud.google.com/gke-tpu-partition-4x4x4-id"
```
Substitua NODE_NAME pelo nome de um dos nós no pool de nós.

O resultado será assim:
```
cloud.google.com/gke-tpu-partition-4x4x4-id=fba785f80d18552357dcdef6d3d16c27
```
A anotação cloud.google.com/gke-tpu-partition-4x4x4-state indica se o nó está disponível para formar uma fração dinâmica. Esse rótulo aceita os seguintes valores:
- HEALTHY: o nó está íntegro e totalmente funcional.
- DEGRADED: o nó está comprometido, mas ainda pode ser usado para a formação de intervalos dinâmicos.
- UNHEALTHY: o nó está com mau funcionamento e não pode ser usado para formar uma fração.
- UNSET: o estado está indefinido devido a um número insuficiente de nós no pool de nós.
- INCOMPLETE: nem todos os nós na partição são provisionados.
Verifique se o nó inclui a anotação node.gke.io/created-by-mig:
```
kubectl describe node NODE_NAME | grep "node.gke.io/created-by-mig"
```
Substitua NODE_NAME pelo nome de um dos nós no pool de nós.

O resultado será assim:
```
node.gke.io/created-by-mig: projects/735972712744/zones/us-central1-ai1a/team/string
```
A saída inclui o rótulo node.gke.io/created-by-mig, que permite que o plano de controle do GKE vincule os nós do Kubernetes aos recursos do Compute Engine subjacentes.

Criar um recurso personalizado de fração

Defina o recurso personalizado Slice:
```
apiVersion: accelerator.gke.io/v1beta1
kind: Slice
metadata:
  # Name of the slice resource
  name: SLICE_NAME
spec:
  # Specify the type of accelerator for this slice
  type: "tpu7x"
  # Define the desired topology for the accelerator slice
  topology: TOPOLOGY
  partitionIds:
    - PARTITION_ID # Example: a9476d1b02bd4f4e75ffffae3bd23c01
    - PARTITION_ID_2
    # ... add more partition IDs as needed
```
Substitua:
- SLICE_NAME: um nome para a fração. O nome precisa atender às condições de metadata.name.
- TOPOLOGY: a topologia da fração dinâmica. A topologia precisa atender às seguintes condições:
  - Cada dimensão da topologia solicitada precisa ser um múltiplo de quatro, por exemplo, 4A x 4B x 4C.
  - Os três valores nas dimensões da topologia, AxBxC, precisam estar em ordem não decrescente (A ≤ B ≤ C). Por exemplo, 4x4x8 é válido, mas 4x8x4 não é. Essa ordem ajuda a garantir uma formação consistente de intervalos e evita comportamentos inesperados.
  - O produto dos três valores nas dimensões da topologia, A × B × C,não pode exceder 9.216.
- PARTITION_ID: uma lista de strings que identificam as partições 4x4x4 que compõem a fração. Calcule o número de partições com base no número total de chips, em que cada partição consiste em 64 chips. O número de itens na sua lista spec.partitionIds precisa corresponder exatamente ao número calculado de partições ((A × B × C) / 64). O partitionIds precisa atender às seguintes condições:
  - Cada partição precisa ser mapeada para um sub-bloco de reserva.
  - Todos os sub-blocos associados precisam pertencer à mesma reserva.
  - Todos os blocos associados precisam estar na mesma reserva.
  - Os pools de nós associados precisam ter todos os nós no estado ready.
- O valor do campo type precisa ser tpu7x.
- Se quiser permitir que o controlador de fração tente de novo automaticamente durante a formação de fração, adicione a anotação slice.gke.io/retry-on-failure: "true" ao recurso personalizado de fração. Se a fração não for criada devido ao motivo do status SliceCreationFailed, o controlador vai tentar de novo até que ela seja formada.
Por exemplo, para criar uma fatia 4x8x8, é necessário fornecer quatro IDs de partição exclusivos.
```
apiVersion: accelerator.gke.io/v1beta1
kind: Slice
metadata:
    name: test-slice-example
    annotations:
      slice.gke.io/retry-on-failure: "true" # Optional annotation to retry slice formation
spec:
    type: "tpu7x"
    topology: "4x8x8" # (4*8*8)/64 = 4 partitions
    partitionIds:
        - "p0"
        - "p1"
        - "p2"
        - "p3"
```
Aplique o recurso personalizado de fração:
```
kubectl apply -f test-slice-example.yaml
```
Nesse ponto, o GKE tenta criar a fração. Se um dos problemas a seguir ocorrer, a criação de intervalos vai falhar, e o motivo do status no recurso personalizado Slice será atualizado para SliceCreationFailed ou FAILED:
- Se os nós selecionados no recurso personalizado não existirem, o motivo do status será SliceCreationFailed.
- Se algum nó no recurso personalizado for usado por outra fração, o motivo do status será SliceCreationFailed.
- Se os nós no recurso personalizado não fizerem parte do mesmo bloco de reserva, o motivo do status será FAILED.
- Se os nós não estiverem na mesma reserva, o motivo do status será FAILED.
- Se a topologia não corresponder ao número de partições, o motivo do status será SliceCreationFailed.
Para saber mais sobre o status do recurso personalizado "Slice", consulte Status da fatia.

Monitorar o status do recurso personalizado Slice

Para verificar o status do recurso personalizado "Slice", execute o seguinte comando:

kubectl describe slice SLICE_NAME

Substitua SLICE_NAME pelo nome da fração.

O resultado será o seguinte:

Name:         test-slice
Namespace:
Labels:       <none>
Annotations:  <none>
API Version:  accelerator.gke.io/v1beta1
Kind:         Slice
Metadata:
  Creation Timestamp:  2026-01-11T23:45:15Z
  Finalizers:
    accelerator.gke.io/slice-finalizer
  Generation:        1
  Resource Version:  1768175347356335006
  UID:               d0b71e5c-be3f-4788-aead-930c7afec4f2
Spec:
  Partition Ids:
    2c79463990ff67c4e3c2648666bfedfa
    ba898ffcac0ad0946e8ff036d771ee53
    [more partition IDs]
  Topology:  8x16x16
  Type:      tpu7x
Status:
  Conditions:
    Last Transition Time:  2026-01-11T23:45:38Z
    Message:               ""
    
    Reason:                FAILED
    
    Status:                False
    Type:                  Ready
Events:

O campo reason no status do recurso personalizado de Slice indica o estado atual da fração. O ciclo de vida de um recurso personalizado Slice segue esta progressão:

SliceNotCreated: o controlador realiza a inicialização e as verificações de recursos.
- Se os pré-requisitos não forem atendidos, o estado vai mudar para SliceCreationFailed.
- Se a validação for aprovada, o estado vai mudar para ACTIVATING.
ACTIVATING: o GKE está formando a fração.
- Se for bem-sucedido, o estado vai mudar para ACTIVE.
- Se os sub-blocos estiverem degradados, mas a fração for utilizável, o estado vai mudar para ACTIVE_DEGRADED.
- Se a formação falhar, o estado vai mudar para FAILED.
DEACTIVATING: se o recurso personalizado de Slice for excluído ou ocorrer uma falha crítica em um estado ativo ou com falha, a fração começará a ser desmontada.
INCOMPLETE: a etapa final antes da exclusão completa do recurso.

Para saber mais sobre o status do recurso personalizado "Slice", consulte Status da fatia.

Executar cargas de trabalho em segmentação dinâmica

Quando o recurso personalizado de fração está no estado ACTIVE, é possível executar cargas de trabalho nele. A seção a seguir inclui exemplos de cargas de trabalho que usam o segmentação dinâmica. As cargas de trabalho são enviadas como jobs ou JobSets.

Exemplo 1: uma única carga de trabalho usa uma única fração

O exemplo a seguir mostra uma carga de trabalho que usa uma única fração de sub-bloco.

Salve o seguinte manifesto de amostra como tpu-job-jax-v7x-64.yaml:

apiVersion: v1
kind: Service
metadata:
name: headless-svc
spec:
clusterIP: None
selector:
    job-name: tpu-job-jax-v7x-64
---
apiVersion: batch/v1
kind: Job
metadata:
name: tpu-job-jax-v7x-64
spec:
backoffLimit: 0
completions: 16
parallelism: 16
completionMode: Indexed
template:
    metadata:
    annotations:
        cloud.google.com/gke-tpu-slice-topology: 4x4x4
    spec:
    nodeSelector:
        cloud.google.com/gke-tpu-topology: 4x4x4
        cloud.google.com/gke-tpu-accelerator: tpu7x
        cloud.google.com/gke-tpu-slice: test-slice
    subdomain: headless-svc
    restartPolicy: Never
    containers:
    - name: tpu-job-jax
        env:
        - name: TPU_ACCELERATOR_TYPE
          value: tpu7x-128
        image: python:3.12
        securityContext:
        privileged: false
        command:
        - bash
        - -c
        - |
        set -ex
        pip install -U --pre jax jaxlib libtpu requests -i https://us-python.pkg.dev/ml-oss-artifacts-published/jax/simple/ -f https://storage.googleapis.com/jax-releases/libtpu_releases.html
        pip list
        python -c 'import jax; print("Total TPU devices (cores):", jax.device_count())'
        resources:
        requests:
            google.com/tpu: 4
        limits:
            google.com/tpu: 4

Nesse manifesto:

cloud.google.com/gke-tpu-slice-topology e cloud.google.com/gke-tpu-topology definem a topologia da fração dinâmica.
env.value: tpu7x-128 é o tipo de acelerador de TPU e o número total de núcleos na fração. O número de núcleos é calculado multiplicando as dimensões da topologia pelo número de núcleos por chip. Por exemplo, para uma topologia 4x4x4, o cálculo é 4 × 4 × 4 × 2 = 128, em que 2 é o número de núcleos por chip para tpu7x (Ironwood (TPU7x)). Portanto, o TPU_ACCELERATOR_TYPE é tpu7x-128.

Aplique o manifesto tpu-job-jax-v7x-64.yaml:

kubectl apply -f tpu-job-jax-v7x-64.yaml

Exemplo 2: implante uma carga de trabalho em pools de nós multislice usando JobSet

Este exemplo demonstra como implantar uma carga de trabalho em pools de nós multislice usando o JobSet.

Instale o JobSet:

kubectl apply --server-side -f https://github.com/kubernetes-sigs/jobset/releases/download/v0.10.1/manifests.yaml

Salve o seguinte manifesto de amostra como tpu-multislice-jax.yaml:

apiVersion: jobset.x-k8s.io/v1alpha2
kind: JobSet
metadata:
  name: tpu-multislice-jax
  annotations:
    alpha.jobset.sigs.k8s.io/exclusive-topology: cloud.google.com/gke-tpu-slice
spec:
  failurePolicy:
    maxRestarts: 3
  replicatedJobs:
  - name: slice-job
    replicas: 2
    template:
      spec:
        parallelism: 16
        completions: 16
        backoffLimit: 0
        completionMode: Indexed
        template:
          metadata:
            annotations:
              # The shape of the slice
              cloud.google.com/gke-tpu-slice-topology: 4x4x4
          spec:
            hostNetwork: true
            dnsPolicy: ClusterFirstWithHostNet
            nodeSelector:
              cloud.google.com/gke-tpu-topology: 4x4x4
              cloud.google.com/gke-tpu-accelerator: tpu7x
              # IMPORTANT: Do NOT put 'cloud.google.com/gke-tpu-slice' here manually.
              # The exclusive-topology annotation handles the slice assignment automatically.
            containers:
            - name: jax-worker
              image: python:3.12
              securityContext:
                privileged: true
              ports:
              - containerPort: 8471
              command:
              - bash
              - -c
              - |
                set -ex
                pip install -U --pre jax jaxlib libtpu requests -f https://storage.googleapis.com/jax-releases/libtpu_releases.html
                # Verify JobSet injected the specific slice ID for this worker
                echo "JobSet Index: $JOB_COMPLETION_INDEX"
                python -c 'import jax; print("Total TPU devices:", jax.device_count())'
              resources:
                requests:
                  google.com/tpu: 4
                limits:
                  google.com/tpu: 4

Aplique o manifesto tpu-multislice-jax.yaml:
```
kubectl apply -f tpu-multislice-jax.yaml
```
Nesse manifesto:
- O campo replicas: 2 em replicatedJobs indica que o JobSet cria dois jobs separados, cada um correspondente a uma fração de TPU 4x4x4.
- A anotação alpha.jobset.sigs.k8s.io/exclusive-topology: cloud.google.com/gke-tpu-slice ajuda a garantir que cada job seja atribuído a uma fração de TPU exclusiva.
- A anotação cloud.google.com/gke-tpu-slice-topology: 4x4x4 define a topologia de cada fração dinâmica.
- A variável de ambiente TPU_ACCELERATOR_TYPE não está definida explicitamente neste exemplo porque o JobSet processa a atribuição de fração. O código JAX detecta automaticamente os dispositivos TPU disponíveis na fração atribuída.
Importante: não edite o rótulo cloud.google.com/gke-tpu-slice manualmente.

Excluir a fração

Exclua a fração:

kubectl patch slice $SLICE_NAME --type json \
  -p='[{"op": "remove", "path": "/metadata/finalizers"}]'

Verifique se a fração foi excluída:
```
kubectl get slices
```

Desativar o controlador de fração

Para desativar o controlador de fração, remova-o do cluster.

Verifique se os recursos personalizados de Slice estão vazios:
```
kubectl get slice -A
```

Atualize o cluster para desativar o controlador de fração:

gcloud container clusters update ${CLUSTER_NAME} \
    --location=${REGION} \
    --no-enable-slice-controller

Exclua o recurso personalizado Slice :

kubectl delete crd slices.accelerator.gke.io

Verifique se o recurso personalizado Slice foi excluído:
```
kubectl get crd | grep slices.accelerator.gke.io
```

Remova os rótulos adicionados pelo controlador de segmentação. É necessário remover estes rótulos:

cloud.google.com/gke-tpu-slice
cloud.google.com/gke-tpu-topology

Para remover de um nó específico, atualize o nome dele.

export NODE_NAME="gke-tpu-bdac9600-3bdg"
kubectl label node $NODE_NAME cloud.google.com/gke-tpu-slice- cloud.google.com/gke-tpu-slice-topology-

Se você quiser remover esses rótulos de todos os nós do cluster:

kubectl label nodes --all cloud.google.com/gke-tpu-slice- cloud.google.com/gke-tpu-slice-topology-

Verifique os rótulos do nó e confirme se eles estão vazios:

export NODE_NAME="gke-tpu-bdac9600-3bdg"
kubectl describe node $NODE_NAME | grep "cloud.google.com/gke-tpu-slice"

A seguir

Saiba mais sobre os conceitos de segmentação dinâmica.
Saiba mais sobre o recurso personalizado Slice.

Usar o particionamento dinâmico com um programador personalizado Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Por que usar o corte dinâmico com um programador personalizado?

Visão geral do fluxo de trabalho

Requisitos

Antes de começar

Ativar o controlador de fração

Criar pools de nós com provisionamento incremental

Criar uma política de carga de trabalho

Faça com que seu pool de nós pertença a um bloco ou sub-bloco

Bloquear

Sub-bloco

Formar uma fração dinâmica

Verificar o status dos nós e das partições

Criar um recurso personalizado de fração

Monitorar o status do recurso personalizado Slice

Executar cargas de trabalho em segmentação dinâmica

Exemplo 1: uma única carga de trabalho usa uma única fração

Exemplo 2: implante uma carga de trabalho em pools de nós multislice usando JobSet

Excluir a fração

Desativar o controlador de fração

A seguir

Usar o particionamento dinâmico com um programador personalizado