Como gerenciar o Batch nos clusters do GKE

Esta página mostra como criar e gerenciar o Batch nos clusters do GKE.

Antes de começar

Prepare-se para a tarefa tomando as seguintes medidas:

  • Verifique se você ativou a API Google Kubernetes Engine.
  • Ativar a API Google Kubernetes Engine
  • Verifique se o SDK do Cloud está instalado.
  • Defina o ID do projeto padrão:
    gcloud config set project [PROJECT_ID]
  • Se você estiver trabalhando com clusters zonais, defina a zona do Compute padrão:
    gcloud config set compute/zone [COMPUTE_ZONE]
  • Se você estiver trabalhando com clusters regionais, defina a região do Compute padrão:
    gcloud config set compute/region [COMPUTE_REGION]
  • Atualize gcloud para a versão mais recente:
    gcloud components update

No Beta, o Batch no GKE (Batch) suporta apenas clusters regionais. Crie um cluster regional e ative a Identidade da carga de trabalho.

Execute o seguinte comando para criar um cluster regional com a Identidade da carga de trabalho ativada:

gcloud beta container clusters create [CLUSTER_NAME] \
  --region [COMPUTE_REGION] \
  --node-locations [COMPUTE_ZONE] \
  --num-nodes 1 \
  --machine-type n1-standard-8 \
  --release-channel regular \
  --enable-stackdriver-kubernetes \
  --identity-namespace=[PROJECT_ID].svc.id.goog \
  --enable-ip-alias

Como configurar o gerenciamento de identidade e acesso

  1. Vincule sua conta como proprietário do projeto:

    gcloud projects add-iam-policy-binding [PROJECT_ID] \
    --member user:[EMAIL] --role=roles/owner
    
  2. Crie um papel personalizado com permissões de leitura em clusters do GKE:

    gcloud iam roles create BatchUser --project [PROJECT_ID] \
    --title GKEClusterReader --permissions container.clusters.get --stage BETA 2>&1
    

    em que:

    • [PROJECT_ID] é o ID do projeto.
    • GKEClusterReader é o título do papel.
  3. Crie um ClusterRoleBinding no cluster para permitir que o Batch crie papéis no Kubernetes:

    kubectl create clusterrolebinding cluster-admin-binding-[EMAIL] \
    --clusterrole=cluster-admin --user [EMAIL]
    

    em que [EMAIL] é seu endereço de e-mail.

  4. Crie uma conta de serviço do Google:

    gcloud iam service-accounts create kbatch-controllers-gcloud-sa --display-name \
    kbatch-controllers-gcloud-service-account
    
  5. Crie uma conta de serviço do Kubernetes:

    kubectl create serviceaccount --namespace kube-system kbatch-controllers-k8s-sa
    
  6. Adicione as seguintes vinculações de política de IAM:

    gcloud projects add-iam-policy-binding [PROJECT_ID] \
    --member serviceAccount:kbatch-controllers-gcloud-sa@[PROJECT_ID].iam.gserviceaccount.com \
    --role=roles/container.clusterAdmin
    
    gcloud projects add-iam-policy-binding [PROJECT_ID] \
    --member serviceAccount:kbatch-controllers-gcloud-sa@[PROJECT_ID].iam.gserviceaccount.com \
    --role=roles/compute.admin
    
    gcloud projects add-iam-policy-binding [PROJECT_ID] \
    --member serviceAccount:kbatch-controllers-gcloud-sa@[PROJECT_ID].iam.gserviceaccount.com \
    --role=roles/iam.serviceAccountUser
    
    gcloud iam service-accounts add-iam-policy-binding \
    --role roles/iam.workloadIdentityUser \
    --member "serviceAccount:[PROJECT_ID].svc.id.goog[kube-system/kbatch-controllers-k8s-sa]" kbatch-controllers-gcloud-sa@[PROJECT_ID].iam.gserviceaccount.com
    

    em que [PROJECT_ID] é o ID do projeto.

  7. Adicione a anotação iam.gke.io/gcp-service-account à conta de serviço do Kubernetes:

    kubectl annotate serviceaccount --namespace kube-system kbatch-controllers-k8s-sa \
     iam.gke.io/gcp-service-account=kbatch-controllers-gcloud-sa@[PROJECT].iam.gserviceaccount.com
    

Como ativar GPUs

Se você quiser executar jobs da GPU, execute o seguinte comando para garantir que os drivers adequados sejam instalados quando os nós da GPU forem criados:

kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/stable/nvidia-driver-installer/cos/daemonset-preloaded.yaml

Como instalar o Batch no GKE

Para instalar o Batch, execute as seguintes etapas:

  1. Faça o download da versão do Batch no GitHub.

  2. Extraia o arquivo tar:

    tar zxvf kbatch-[VERSION].tar.gz
    
  3. Altere para o diretório kbatch:

    cd kbatch
    
  4. Adicione suas informações ao arquivo Config:

    vi config/kbatch-config.yaml
    
    ...
    ClusterName: [CLUSTER_NAME]
     ClusterLocation : [COMPUTE_REGION]
     ProjectID: [PROJECT_ID]
     Recommender:
       Locations:
       # Note: Only one zone is supported in the Locations list here.
       - [COMPUTE_ZONE]
    Actuator:
    ...
    
  5. Crie configmaps:

    kubectl create configmap --from-file config/kbatch-config.yaml -n kube-system kbatch-config
    
  6. Crie tipos de máquinas de escalonador automático:

    gcloud compute machine-types list --filter="zone:[COMPUTE_ZONE]" --format json > ./machine_types.json
    
    kubectl create configmap --from-file ./machine_types.json -n kube-system kbatch-machine-types
    
  7. Instale as definições e os componentes de recursos personalizados do Batch:

    kubectl apply -f install/01-crds.yaml
    
    kubectl apply -f install/02-admission.yaml
    
    kubectl apply -f install/03-controller.yaml
    
  8. Ative o ksub para usar suas credenciais de usuário para acesso à API:

    gcloud auth application-default login
    
  9. Inicialize o Ksub:

    ./ksub --config --create-default
    
  10. Adicione os valores padrão para projectID, clusterName, e, se você não estiver operando no namespace padrão, namespace no ksubrc:

    vi ~/.ksubrc
    

Como verificar a instalação do Batch

  1. Verifique se os pods kbatch-admission estão em execução:

    kubectl get pods -n kube-system --selector=app=kbatch-admission
    
  2. Verifique se os pods kbatch-controllers estão em execução:

    kubectl get pods -n kube-system --selector=control-plane=kbatch-controllers
    

Depois de verificar a instalação do Batch, é possível executar os jobs de amostra

Como gerenciar o Batch em versões do GKE

É possível fazer upgrade e downgrade, bem como desinstalar o Batch.

Como atualizar o Batch

Para fazer upgrade para uma nova versão secundária ou de patch, execute os seguintes comandos:

  1. Exclua os arquivos .yaml de admissão e controladores atuais:

    kubectl delete -f kbatch-[CURRENT_VERSION]/install/02-admission.yaml \
    kubectl delete -f kbatch-[CURRENT_VERSION]/install/03-controllers.yaml
    
  2. Aplique os novos arquivos .yaml de admissão e controladores.

    kubectl apply -f kbatch-[NEW_VERSION]/install/02-admission.yaml \
    kubectl apply -f kbatch-[NEW_VERSION]/install/03-controllers.yaml
    

Para atualizar para uma nova versão principal, instale a nova versão em um novo cluster ou siga as etapas em Desinstalação do Batch e instale a nova versão principal.

Downgrade do Batch

Só é possível reverter para a versão secundária ou de patch anterior.

Para reverter para uma versão anterior, execute os seguintes comandos:

  1. Exclua os arquivos .yaml de admissão e controladores atuais:

    kubectl delete -f kbatch-[CURRENT_VERSION]/install/02-admission.yaml \
    kubectl delete -f kbatch-[CURRENT_VERSION]/install/03-controllers.yaml
    
  2. Aplique os novos arquivos .yaml de admissão e controladores.

    kubectl apply -f kbatch-[OLD_VERSION]/install/02-admission.yaml \
    kubectl apply -f kbatch-[OLD_VERSION]/install/03-controllers.yaml
    

Desinstalação do Batch

Para desinstalar o Batch, execute as seguintes etapas:

  1. Verifique qual das versões do Batch está sendo executada verificando as tags da imagem:

    kubectl get deployment kbatch-admission -n kube-system -o jsonpath="{..image}"
    kubectl get statefulset kbatch-controllers -n kube-system -o jsonpath="{..image}"
    
  2. Exclua o pacote de instalação do cluster:

    kubectl delete -f kbatch-[VERSION]/install/
    

Como depurar o Batch no GKE usando o Stackdriver

O Batch usa o Prometheus como a ferramenta de monitoramento. É possível visualizar suas métricas kbatch-controller-service no Stackdriver Monitoring. As métricas geradas pelos serviços do Batch são consideradas como métricas externas no Stackdriver.

As métricas personalizadas são um recurso sujeito a cobrança do Stackdriver Monitoring e talvez haja custos para as métricas personalizadas. Para mais informações sobre preços, consulte Preços do Stackdriver.

Antes de começar

Como configurar o gerenciamento de identidade e acesso

  1. Crie uma conta de serviço do Google:

    gcloud iam service-accounts create kbatch-monitoring-gcloud-sa \
    --display-name kbatch-monitoring-gcloud-service-account
    
  2. Crie uma conta de serviço do Kubernetes:

    kubectl create serviceaccount --namespace kube-system kbatch-monitoring-k8s-sa
    
  3. Adicione as seguintes vinculações de política de IAM:

    gcloud projects add-iam-policy-binding [PROJECT_ID] \
    --member serviceAccount:kbatch-monitoring-gcloud-sa@[PROJECT_ID].iam.gserviceaccount.com \
    --role=roles/monitoring.metricWriter
    
    gcloud projects add-iam-policy-binding [PROJECT_ID] \
    --member serviceAccount:kbatch-monitoring-gcloud-sa@[PROJECT_ID].iam.gserviceaccount.com \
    --role=roles/monitoring.viewer
    
    gcloud iam service-accounts add-iam-policy-binding \
    --role roles/iam.workloadIdentityUser \
    --member "serviceAccount:[PROJECT_ID].svc.id.goog[kube-system/kbatch-monitoring-k8s-sa]" kbatch-monitoring-gcloud-sa@[PROJECT_ID].iam.gserviceaccount.com
    

    em que [PROJECT_ID] é o ID do projeto.

  4. Adicione a anotação iam.gke.io/gcp-service-account à conta de serviço do Kubernetes:

    kubectl annotate serviceaccount --namespace kube-system kbatch-monitoring-k8s-sa \
     iam.gke.io/gcp-service-account=kbatch-monitoring-gcloud-sa@[PROJECT].iam.gserviceaccount.com
    
  5. Acesse as ferramentas de administração:

    git clone https://github.com/GoogleCloudPlatform/Kbatch.git
    
  6. Acesse o diretório de monitoramento:

    cd admintools/monitoring
    

Implantar serviço Prometheus

  1. Para implantar o serviço Prometheus, execute o seguinte comando:

    kubectl apply -f prometheus.yaml
    
  2. Para validar a implantação do Prometheus, execute o seguinte comando:

    kubectl get pod -n kube-system | grep 'kbatch-prometheus'
    

    A saída é semelhante a esta:

    kbatch-prometheus-deployment-97bc6b97b-m4q9h       1/1     Running   0          9s
    

Como instalar o coletor do Stackdriver

Depois, implante o contêiner do arquivo secundário como o coletor do Stackdriver. O arquivo secundário exporta as métricas do Prometheus para o Stackdriver.

  1. Para implantar o coletor do Stackdriver, execute o seguinte comando:

    sh ./setup_metrics_export_to_sd.sh
    
  2. Para validar a instalação do coletor do Stackdriver, execute o seguinte comando:

    kubectl -n kube-system get deployment kbatch-prometheus-deployment -o=go-template='{{$output := "stackdriver-prometheus-sidecar does not exists."}}{{range .spec.template.spec.containers}}{{if eq .name "sidecar"}}{{$output = (print "sidecar exists. Image: " .image)}}{{end}}{{end}}{{printf $output}}{{"\n"}}'
    

    Após o arquivo secundário do Prometheus ser instalado com sucesso, a saída do script lista a imagem usada no registro do contêiner.

    sidecar exists. Image: gcr.io/kbatch-images/stackdriver-prometheus-sidecar:0.6.1
    

    Caso contrário, a saída do script mostrará:

    stackdriver-prometheus-sidecar does not exist.
    

Como ver métricas

  1. Acessar o Metrics Explorer.

    Acessar o Metrics Explorer

  2. Vá para Resources > Metrics Explorer. No campo Find resource type and metric, selecione aquele com prefixo external/prometheus/.

    Por exemplo, é possível selecionar external/prometheus/kbatch_scheduling_dep.

    É possível adicionar várias métricas em um espaço de trabalho.

Desativar o coletor do Stackdriver

Para desativar o contêiner do arquivo secundário, execute o seguinte comando a partir do diretório kbatch.

sh ./disable_metrics_export_to_sd.sh

Limpar

Para interromper a execução de serviços do Batch em um cluster do GKE, execute os seguintes comandos:

kubectl delete deployment kbatch-admission --namespace=kube-system
kubectl delete statefulset kbatch-controllers --namespace=kube-system

Para excluir o cluster do GKE com o Batch instalado, execute o seguinte comando:

gcloud container clusters delete [CLUSTER_NAME] --region [REGION]

Para excluir a instância do Filestore, execute o seguinte comando:

gcloud beta filestore instances delete [FILESTORE_INSTANCE_ID] \
  --project=[PROJECT_ID] --location=[FILESTORE_ZONE]

em que [FILESTORE_INSTANCE_ID] é o ID da instância do Filestore, [PROJECT_ID] é o ID do projeto e [FILESTORE_ZONE] é a zona.

Para excluir o projeto que tem o Batch instalado, execute o seguinte comando:

gcloud projects delete [PROJECT_ID]

A seguir