Container Service for Kubernetes：Praktik Terbaik untuk Menggunakan Arena dalam Skenario Multi-Penyewa

Prasyarat

Informasi Latar Belakang

Dalam beberapa skenario, beberapa pengembang di perusahaan atau tim ingin menggunakan Arena untuk mengirimkan pekerjaan. Untuk meningkatkan efisiensi manajemen pekerjaan, Anda dapat membagi pengembang menjadi beberapa grup pengguna dan memberikan setiap grup pengguna izin yang berbeda. Ini memungkinkan Anda untuk mengalokasikan dan mengisolasi sumber daya, serta mengelola izin berdasarkan grup pengguna.

Tugas

Langkah 1: Buat dan kelola pengguna dan grup pengguna untuk kluster ACK

Untuk memastikan keamanan, kami sarankan agar Anda tidak menginstal Arena, menjalankan Arena, atau mengelola kluster ACK pada node master. Anda dapat membuat instance ECS di VPC tempat kluster ACK diterapkan dan menginstal Arena pada instance ECS. Dalam contoh ini, instance ECS berfungsi sebagai klien. Anda dapat membuat file kubeconfig untuk memungkinkan instance ECS mengakses kluster ACK.

1. Buat pengguna dan grup pengguna pada klien.

   1. Gunakan kubectl untuk terhubung ke kluster ACK.

      Sebelum Anda dapat menggunakan kubectl, Anda harus menginstal kubectl pada klien dan memodifikasi file kubeconfig untuk mengizinkan administrator mengelola kluster ACK. Untuk informasi lebih lanjut, lihat Dapatkan file kubeconfig kluster dan gunakan kubectl untuk terhubung ke kluster.

      Catatan

      Versi kubectl harus 1.10 atau lebih baru.

   2. Jalankan perintah berikut untuk membuat ID pengguna (UID) dan ID grup (GID) di Linux untuk pengguna dan grup pengguna yang sesuai pada klien.

      Dalam contoh ini, buat UID dan GID untuk Bob dan Tom, serta buat grup pengguna dev1 dan dev2 pada klien. Gunakan sistem akun Linux untuk menyelesaikan Tugas 2: Setiap pengguna hanya dapat masuk ke klien dengan nama pengguna dan kata sandi mereka sendiri, dan hanya dapat menjalankan Arena di lingkungan mereka sendiri.

      # Buat grup Linux: dev1 dan dev2.
      groupadd -g 10001 dev1
      groupadd -g 10002 dev2
      
      # Buat pengguna Linux: Bob dan Tom.
      adduser -u 20001 -s /bin/bash -G dev1 -m bob
      adduser -u 20002 -s /bin/bash -G dev2 -m tom
      
      # Atur kata sandi untuk Bob untuk masuk ke klien. 
      passwd bob 
      # Atur kata sandi untuk Tom untuk masuk ke klien. 
      passwd tom

2. Buat akun layanan dan namespace untuk kluster ACK.

   Setelah Anda mengirimkan pekerjaan, pekerjaan tersebut akan berjalan di kluster ACK. Setiap pengguna pada klien sesuai dengan akun layanan di kluster ACK dan setiap grup pengguna sesuai dengan namespace. Oleh karena itu, Anda harus membuat akun layanan dan namespace, dan pastikan bahwa mereka dipetakan ke pengguna dan grup pengguna yang sesuai pada klien. Anda harus memetakan namespace ke grup pengguna, dan memetakan akun layanan ke pengguna.

   Masuk ke klien sebagai pengguna root. Pastikan bahwa pengguna root memiliki izin untuk mengelola kluster ACK. Untuk informasi lebih lanjut, lihat bagian Gunakan kubectl untuk terhubung ke kluster ACK dari topik ini. Jalankan perintah berikut:

   # Buat namespace untuk grup pengguna dev1. 
   kubectl create namespace dev1
   
   # Buat namespace untuk grup pengguna dev2. 
   kubectl create namespace dev2
   
   # Buat akun layanan untuk Bob. 
   kubectl create serviceaccount bob -n dev1
   
   # Buat akun layanan untuk Tom. 
   kubectl create serviceaccount tom -n dev2

   Output yang Diharapkan:

   $ kubectl create namespace dev1
   namespace/dev1 created
   
   $ kubectl create namespace dev2
   namespace/dev2 created
   
   $ kubectl create serviceaccount bob -n dev1
   serviceaccount/bob created
   
   $ kubectl create serviceaccount tom -n dev2
   serviceaccount/tom created

Langkah 2: Konfigurasikan Arena untuk pengguna

1. Instal Arena.

   Instal Arena pada klien. Masuk ke klien sebagai pengguna root dan unduh paket instalasi terbaru Arena yang dirilis di komunitas. Kemudian, ekstrak paket dan jalankan skrip install.sh. Untuk informasi lebih lanjut, lihat Konfigurasi klien Arena.

   Catatan

   Anda hanya perlu menginstal Arena sekali pada setiap klien Linux. Untuk memungkinkan setiap pengguna menggunakan Arena di lingkungan terpisah, Anda harus membuat file kubeconfig untuk setiap pengguna.

2. Buat file kubeconfig untuk setiap pengguna.

   Untuk memungkinkan setiap pengguna menggunakan Arena di lingkungan terpisah, Anda harus membuat file kubeconfig untuk setiap pengguna (akun layanan). Anda dapat memberikan izin yang berbeda kepada pengguna pada kluster ACK. Ini memastikan keamanan data.

   Masuk ke klien sebagai pengguna root. Buat skrip bernama generate-kubeconfig.sh dan tempelkan konten berikut ke dalam skrip:

   #!/usr/bin/env bash
   
   set -e
   
   NAMESPACE=
   SERVICE_ACCOUNT=
   DURATION=
   OUTPUT=
   
   help() {
       echo "Penggunaan: $0 -n <namespace> -s <service-account> -d <duration> -o <output-file>"
       echo ""
       echo "Opsi:"
       echo "-n, --namespace <namespace>      Namespace dari akun layanan."
       echo "-s, --service-account <name>     Nama akun layanan."
       echo "-d, --duration <duration>        Durasi token misalnya 30d."
       echo "-o, --output <file>              Nama file output. Jika tidak diatur, file sementara akan dibuat."
   }
   
   parse() {
       while [ $# -gt 0 ]; do
           case $1 in
           -n | --namespace)
               NAMESPACE="$2"
               shift 2
               ;;
           -s | --service-account)
               SERVICE_ACCOUNT="$2"
               shift 2
               ;;
           -d | --duration)
               DURATION="$2"
               shift 2
               ;;
           -o | --output)
               OUTPUT="$2"
               shift 2
               ;;
           *)
               help
               exit 0
               ;;
           esac
       done
   
       if [ -z "${NAMESPACE}" ] || [ -z "${SERVICE_ACCOUNT}" ] || [ -z "${DURATION}" ]; then
           help
           exit 0
       fi
   
       if [ -z "${OUTPUT}" ]; then
           OUTPUT=$(mktemp -d)/config
       elif [ -f "${OUTPUT}" ]; then
           echo "File output \"${OUTPUT}\" sudah ada."
           exit 1
       fi
   }
   
   # Hasilkan kubeconfig
   generate_kubeconfig() {
       CONTEXT=$(kubectl config current-context)
       CLUSTER=$(kubectl config view -o jsonpath="{.contexts[?(@.name==\"${CONTEXT}\")].context.cluster}")
       SERVER=$(kubectl config view -o jsonpath="{.clusters[?(@.name==\"${CLUSTER}\")].cluster.server}")
       TOKEN=$(kubectl create token "${SERVICE_ACCOUNT}" --namespace "${NAMESPACE}" --duration="${DURATION}")
       CERT=$(mktemp)
   
       mkdir -p "$(dirname "${OUTPUT}")"
       kubectl config view --raw=true -o jsonpath="{.clusters[?(@.name==\"${CLUSTER}\")].cluster.certificate-authority-data}" | base64 -d >"${CERT}"
       kubectl config set-cluster "${CLUSTER}" --kubeconfig="${OUTPUT}" --server="${SERVER}" --embed-certs=true --certificate-authority="${CERT}" >/dev/null
       kubectl config set-credentials "${SERVICE_ACCOUNT}" --kubeconfig="${OUTPUT}" --token="${TOKEN}" >/dev/null
       kubectl config set-context "${CLUSTER}-${NAMESPACE}-${SERVICE_ACCOUNT}-context" --kubeconfig="${OUTPUT}" --cluster="${CLUSTER}" --user="${SERVICE_ACCOUNT}" --namespace="${NAMESPACE}" >/dev/null
       kubectl config use-context "${CLUSTER}-${NAMESPACE}-${SERVICE_ACCOUNT}-context" --kubeconfig="${OUTPUT}" >/dev/null
       rm "${CERT}"
       echo "Kubeconfig tersimpan di \"${OUTPUT}\"."
   }
   
   main() {
       parse "$@"
       generate_kubeconfig
   }
   
   main "$@"

   Jalankan perintah berikut untuk membuat file bernama KubeConfig dan simpan di direktori home Anda. Perintah di bawah ini mengatur waktu kedaluwarsa menjadi 720 jam, tetapi Anda dapat menyesuaikan waktu kedaluwarsa ini sesuai kebutuhan.

   bash generate-kubeconfig.sh -n dev1 -s bob -d 720h  -o /home/bob/.kube/config
   bash generate-kubeconfig.sh -n dev2 -s tom -d 720h  -o /home/tom/.kube/config

   Output yang Diharapkan:

   $ bash generate-kubeconfig.sh -n dev1 -s bob -d 720h  -o /home/bob/.kube/config
   Saved kubeconfig to "/home/bob/.kube/config".
   
   $ bash generate-kubeconfig.sh -n dev2 -s tom -d 720h  -o /home/tom/.kube/config
   Saved kubeconfig to "/home/tom/.kube/config".

   Setelah Anda melakukan operasi di atas, Anda dapat masuk ke klien dengan akun Bob atau Tom, lalu menjalankan Arena di lingkungan terpisah. Setelah Anda menyelesaikan Langkah 1 dan Langkah 2, Tugas 1 dan Tugas 2 selesai.

Langkah 3: Berikan izin yang berbeda kepada pengguna pada Arena

1. Buat peran yang diperlukan di namespace kluster ACK.

   Anda dapat membuat peran dengan izin yang berbeda di namespace kluster ACK. Setiap peran di namespace berisi satu set aturan izin. Untuk informasi lebih lanjut tentang cara membuat peran, lihat Menggunakan Otorisasi RBAC.

   1. Buat file definisi peran.

      Buat peran di grup pengguna dev1 dan dev2, dan tetapkan peran tersebut ke Bob dan Tom secara terpisah. Dalam contoh ini, berikan Bob dan Tom izin minimum. Ini memungkinkan mereka untuk melihat dan mengelola hanya pekerjaan yang mereka kirimkan.

      Gunakan kode sampel berikut untuk membuat file definisi peran bernama dev1_roles.yaml untuk grup pengguna dev1:

      kind: ClusterRole
      apiVersion: rbac.authorization.k8s.io/v1
      metadata:
        name: arena-topnode
      rules:
      - apiGroups:
        - ""
        resources:
        - pods
        - services
        - deployments
        - nodes
        - nodes/*
        - services/proxy
        - persistentvolumes
        verbs:
        - get
        - list
      ---
      apiVersion: rbac.authorization.k8s.io/v1
      kind: Role
      metadata:
        name: arena
        namespace: dev1
      rules:
        - apiGroups:
            - ""
          resources:
            - configmaps
          verbs:
            - '*'
        - apiGroups:
            - ""
          resources:
            - services/proxy
            - persistentvolumeclaims
            - events
          verbs:
            - get
            - list
        - apiGroups:
            - ""
          resources:
            - pods
            - pods/log
            - services
          verbs:
            - '*'
        - apiGroups:
            - ""
            - apps
            - extensions
          resources:
            - deployments
            - replicasets
          verbs:
            - '*'
        - apiGroups:
            - kubeflow.org
          resources:
            - '*'
             verbs:
            - '*'
        - apiGroups:
            - batch
          resources:
            - jobs
          verbs:
            - '*'

      Gunakan kode sampel berikut untuk membuat file definisi peran bernama dev2_roles.yaml untuk grup pengguna dev2:

      kind: ClusterRole
      apiVersion: rbac.authorization.k8s.io/v1
      metadata:
        name: arena-topnode
      rules:
      - apiGroups:
        - ""
        resources:
        - pods
        - services
        - deployments
        - nodes
        - nodes/*
        - services/proxy
        - persistentvolumes
        verbs:
        - get
        - list
      ---
      apiVersion: rbac.authorization.k8s.io/v1
      kind: Role
      metadata:
        name: arena
        namespace: dev2
      rules:
      - apiGroups:
        - ""
        resources:
        - configmaps
        verbs:
        - '*'
      - apiGroups:
        - ""
        resources:
        - services/proxy
        - persistentvolumeclaims
        - events
        verbs:
        - get
        - list
      - apiGroups:
        - ""
        resources:
        - pods
        - pods/log
        - services
        verbs:
        - '*'
      - apiGroups:
        - ""
        - apps
        - extensions
        resources:
        - deployments
        - replicasets
        verbs:
        - '*'
      - apiGroups:
        - kubeflow.org
        resources:
        - '*'
        verbs:
        - '*'
      - apiGroups:
        - batch
        resources:
        - jobs
        verbs:
        - '*'

   2. Setelah Anda membuat dev1_roles.yaml dan dev2_roles.yaml, jalankan perintah berikut untuk menerapkan file-file tersebut ke kluster ACK:

      kubectl apply -f dev1_roles.yaml
      
      kubectl apply -f dev2_roles.yaml

      Output yang Diharapkan:

      $ kubectl apply -f dev1_roles.yaml
      clusterrole.rbac.authorization.k8s.io/arena-topnode created
      role.rbac.authorization.k8s.io/arena created
      
      $ kubectl apply -f dev2_roles.yaml
      clusterrole.rbac.authorization.k8s.io/arena-topnode unchanged
      role.rbac.authorization.k8s.io/arena created

   3. Jalankan perintah berikut untuk menanyakan peran di namespace:

      kubectl get role -n dev1
      
      kubectl get role -n dev2

      Output yang Diharapkan:

      $ kubectl get role -n dev1
      NAME    CREATED AT
      arena   2024-09-14T08:25:34Z
      
      $ kubectl get role -n dev2
      NAME    CREATED AT
      arena   2024-09-14T08:25:39Z

2. Berikan izin kepada pengguna pada kluster ACK.

   Setelah Anda membuat peran, Anda harus menetapkan peran tersebut kepada pengguna untuk memberikan mereka izin. Untuk menyelesaikan tugas ini, ikat peran di namespace ke akun layanan.

   Anda dapat menetapkan satu atau lebih peran di namespace yang berbeda kepada setiap pengguna. Ini memungkinkan pengguna mengakses sumber daya yang termasuk dalam namespace yang berbeda. Kontrol akses berbasis peran (RBAC) memungkinkan Anda mengelola izin yang dimiliki pengguna pada namespace. Anda dapat membuat pengikatan peran berdasarkan kebutuhan bisnis.

   Anda dapat menggunakan dua objek Kubernetes, RoleBinding dan ClusterRoleBinding, untuk membuat pengikatan peran yang memberikan izin kepada pengguna pada namespace atau kluster ACK. Untuk informasi lebih lanjut tentang cara menggunakan RoleBinding dan ClusterRoleBinding untuk mendeskripsikan pengikatan peran, lihat Menggunakan Otorisasi RBAC.

   Untuk menyelesaikan Tugas 3, tetapkan peran yang dibuat di Langkah 3 kepada Bob dan Tom. Untuk memberikan izin kepada pengguna, lakukan operasi berikut:

   1. Masuk ke klien sebagai pengguna root, dan gunakan kode sampel berikut untuk membuat file otorisasi bernama bob_rolebindings.yaml untuk pengguna Bob:

      kind: ClusterRoleBinding
      apiVersion: rbac.authorization.k8s.io/v1
      metadata:
        name: bob-arena-topnode
        namespace: dev1
      roleRef:
        apiGroup: rbac.authorization.k8s.io
        kind: ClusterRole
        name: arena-topnode
      subjects:
      - kind: ServiceAccount
        name: bob
        namespace: dev1
      ---
      kind: RoleBinding
      apiVersion: rbac.authorization.k8s.io/v1
      metadata:
        name: bob-arena
        namespace: dev1
      roleRef:
        apiGroup: rbac.authorization.k8s.io
        kind: Role
        name: arena
      subjects:
      - kind: ServiceAccount
        name: bob
        namespace: dev1

      Gunakan kode sampel berikut untuk membuat file otorisasi bernama tom_rolebindings.yaml untuk pengguna Tom:

      kind: ClusterRoleBinding
      apiVersion: rbac.authorization.k8s.io/v1
      metadata:
        name: tom-arena-topnode
        namespace: dev2
      roleRef:
        apiGroup: rbac.authorization.k8s.io
        kind: ClusterRole
        name: arena-topnode
      subjects:
      - kind: ServiceAccount
        name: tom
        namespace: dev2
      ---
      kind: RoleBinding
      apiVersion: rbac.authorization.k8s.io/v1
      metadata:
        name: tom-arena
        namespace: dev2
      roleRef:
        apiGroup: rbac.authorization.k8s.io
        kind: Role
        name: arena
      subjects:
      - kind: ServiceAccount
        name: tom
        namespace: dev2

   2. Jalankan perintah berikut untuk menetapkan peran kepada Bob dan Tom:

      kubectl apply -f bob_rolebindings.yaml
      
      kubectl apply -f tom_rolebindings.yaml

      Output yang Diharapkan:

      $ kubectl apply -f bob_rolebindings.yaml
      clusterrolebinding.rbac.authorization.k8s.io/bob-arena-topnode created
      rolebinding.rbac.authorization.k8s.io/bob-arena created
      
      $ kubectl apply -f tom_rolebindings.yaml
      clusterrolebinding.rbac.authorization.k8s.io/tom-arena-topnode created
      rolebinding.rbac.authorization.k8s.io/tom-arena created

   3. Jalankan perintah berikut untuk menanyakan pengikatan peran di grup pengguna dev1 dan dev2:

      kubectl get rolebinding -n dev1
      
      kubectl get rolebinding -n dev2

      Output yang Diharapkan:

      $ kubectl get rolebinding -n dev1
      NAME        ROLE         AGE
      bob-arena   Role/arena   34s
      
      $ kubectl get rolebinding -n dev2
      NAME        ROLE         AGE
      tom-arena   Role/arena   33s

      Setelah Anda menyelesaikan operasi di atas, tiga tugas pertama selesai.

Langkah 4: Konfigurasikan kuota sumber daya untuk grup pengguna

Anda dapat mengelola semua sumber daya kluster ACK di konsol ACK. Untuk memastikan keamanan dan efisiensi penggunaan sumber daya, Anda dapat menetapkan kuota sumber daya untuk grup pengguna. Anda dapat mengirimkan pekerjaan ke namespace tempat Anda memiliki izin. Saat Anda mengirimkan pekerjaan, ACK secara otomatis memeriksa sumber daya yang tersedia dari namespace. Jika jumlah sumber daya yang diminta oleh pekerjaan melebihi kuota, ACK akan menolak pekerjaan tersebut.

Dalam Kubernetes, objek ResourceQuota menjelaskan batasan yang membatasi konsumsi sumber daya agregat per namespace. Setiap namespace sesuai dengan grup pengguna pada klien tempat Arena diinstal. Anda dapat menetapkan kuota untuk berbagai sumber daya, seperti CPU, memori, dan sumber daya tambahan. Sumber daya tambahan mencakup GPU NVIDIA. Objek ResourceQuota juga membatasi penggunaan sumber daya kontainer dan objek Kubernetes lainnya dalam namespace. Untuk informasi lebih lanjut, lihat Kuota Sumber Daya.

Untuk menyelesaikan Tugas 4, tetapkan kuota sumber daya GPU, CPU, dan memori untuk setiap grup pengguna. Untuk informasi lebih lanjut, lihat tabel Alokasi Sumber Daya dalam topik ini. Dalam contoh ini, satu GPU dialokasikan ke grup pengguna dev1. Sumber daya CPU dan memori tidak terbatas. Bob dalam grup pengguna dev1 dapat menggunakan semua sumber daya CPU dan memori kluster. Kemudian, sumber daya berikut dialokasikan ke dev2: 2 GPU, 8 core CPU, dan 60 GiB memori. Untuk mengonfigurasi kuota sumber daya untuk grup pengguna, lakukan operasi berikut:

Langkah 5: Buat volume NAS untuk menegakkan kontrol akses multi-level

Untuk memenuhi persyaratan kontrol akses multi-level, Anda harus membuat volume yang dapat diakses oleh pengguna dan grup pengguna yang berbeda. Ini memastikan keamanan berbagi data.

Untuk menyelesaikan Tugas 5, Anda harus membuat dua jenis volume bersama. Jenis volume pertama digunakan untuk menyimpan data yang dapat diakses oleh pengguna di kedua grup pengguna. Jenis volume lainnya digunakan untuk menyimpan data yang hanya dapat diakses oleh pengguna dalam grup pengguna tertentu. Untuk informasi lebih lanjut tentang volume bersama, lihat tabel Alokasi Sumber Daya dalam topik ini. Dalam contoh ini, empat volume berikut dibuat: dev1-public, dev2-public, department1-public-dev1, dan department1-public-dev2. department1-public-dev1 dan department1-public-dev2 dipasang ke direktori yang sama dari sistem file NAS. Data volume dapat diakses oleh pengguna di kedua grup pengguna dev1 dan dev2. dev1-public dan dev2-public dipasang ke direktori yang berbeda dari sistem file NAS. Data yang disimpan pada dev1-public hanya dapat diakses oleh Bob dalam grup pengguna dev1, dan data yang disimpan pada dev2-public hanya dapat diakses oleh Tom dalam grup pengguna dev2. Untuk membuat volume NAS untuk berbagi data, lakukan operasi berikut:

1. Buat sistem file NAS.

   Masuk ke konsol NAS, buat sistem file NAS, dan tambahkan target pemasangan. Untuk informasi lebih lanjut, lihat Konfigurasikan volume NAS bersama.

2. Buat volume persisten (PV) dan klaim volume persisten (PVC) untuk kluster ACK.

   1. Buat PV.

      Buat empat PV. Untuk informasi lebih lanjut tentang cara membuat PV, lihat Pasang volume NAS yang diatur secara statis. Volume department1-public-dev1 digunakan untuk berbagi data department1 dengan pengguna dalam grup pengguna dev1, dan volume department1-public-dev2 digunakan untuk berbagi data department1 dengan pengguna dalam grup pengguna dev2. Volume dev1-public digunakan untuk berbagi data hanya dengan pengguna dalam grup pengguna dev1, dan volume dev2-public digunakan untuk berbagi data hanya dengan pengguna dalam grup pengguna dev2. Gambar berikut menunjukkan konfigurasi PV.

      Catatan

      Pilih target pemasangan yang Anda tambahkan pada langkah sebelumnya.

   2. Buat PVC.

      Buat PVC untuk setiap PV baru yang dibuat. Untuk informasi lebih lanjut tentang cara membuat PVC, lihat Pasang volume NAS yang diatur secara statis.

      Setelah PVC dibuat, Anda dapat melihat bahwa department1-public-dev1 dan dev1-public ada di grup pengguna dev1, dan department1-public-dev2 dan dev2-public ada di grup pengguna dev2.

3. Verifikasi konfigurasi volume.

   Masuk ke klien sebagai pengguna root, dan jalankan perintah berikut untuk menanyakan volume yang digunakan oleh grup pengguna dev1 dan dev2:

   # Tanyakan volume yang digunakan oleh grup pengguna dev1. 
   arena data list -n dev1
   
   # Tanyakan volume yang digunakan oleh grup pengguna dev2. 
   arena data list -n dev2

   Output yang Diharapkan:

   

   Setelah Anda menyelesaikan operasi di atas, kelima tugas selesai. Contoh berikut menjelaskan cara masuk ke klien tempat Arena diinstal dengan akun Bob dan Tom.

Langkah 6: Jalankan Arena dengan akun pengguna yang berbeda

Use the account of Bob

1. Jalankan perintah berikut untuk masuk ke klien dan menanyakan volume bersama yang tersedia:

   # Masuk ke klien dengan akun Bob.
   ssh bob@39.98.xxx.xx
   
   # Jalankan perintah arena data list untuk menanyakan volume bersama yang tersedia untuk Bob. 
   arena data list

   Output yang Diharapkan:

   

2. Jalankan perintah berikut untuk mengirimkan pekerjaan pelatihan yang memerlukan satu GPU:

   arena submit tf \
           --name=tf-git-bob-01 \
           --gpus=1 \
           --image=tensorflow/tensorflow:1.5.0-devel-gpu \
           --sync-mode=git \
           --sync-source=https://code.aliyun.com/xiaozhou/tensorflow-sample-code.git \
           "python code/tensorflow-sample-code/tfjob/docker/mnist/main.py --max_steps 10000 --data_dir=code/tensorflow-sample-code/data"

3. Jalankan perintah berikut untuk mendaftar semua pekerjaan yang dikirimkan oleh Bob:

   arena list

   Output yang Diharapkan:

   

4. Jalankan perintah berikut untuk mengirimkan pekerjaan pelatihan lain yang memerlukan satu GPU:

   arena submit tf \
           --name=tf-git-bob-02 \
           --gpus=1 \
           --image=tensorflow/tensorflow:1.5.0-devel-gpu \
           --sync-mode=git \
           --sync-source=https://code.aliyun.com/xiaozhou/tensorflow-sample-code.git \
           "python code/tensorflow-sample-code/tfjob/docker/mnist/main.py --max_steps 10000 --data_dir=code/tensorflow-sample-code/data"

   Dalam contoh ini, hanya satu GPU yang dialokasikan ke grup pengguna dev1. Oleh karena itu, ACK diharapkan menolak pekerjaan kedua.

   

   Gambar di atas menunjukkan bahwa kluster ACK masih memiliki sumber daya yang cukup. Namun, GPU yang dialokasikan ke grup pengguna tempat Bob berasal sudah ditempati oleh pekerjaan pertama. Akibatnya, pekerjaan kedua ditangguhkan.

Use the account of Tom

1. Jalankan perintah berikut untuk masuk ke klien dan menanyakan volume bersama yang tersedia:

   # Masuk ke klien dengan akun Tom. 
   ssh tom@39.98.xx.xx
   
   # Jalankan perintah arena data list untuk menanyakan volume bersama yang tersedia untuk Tom. 
   arena data list

   Output yang Diharapkan:

   

2. Jalankan perintah berikut untuk mendaftar semua pekerjaan yang dikirimkan oleh Tom:

   arena list

   Tom tidak dapat melihat pekerjaan yang dikirimkan oleh Bob.

3. Jalankan perintah berikut untuk mengirimkan pekerjaan pelatihan yang memerlukan satu GPU:

    arena submit tf \
            --name=tf-git-tom-01 \
            --gpus=1 \
            --chief-cpu=2 \
            --chief-memory=10Gi \
            --image=tensorflow/tensorflow:1.5.0-devel-gpu \
            --sync-mode=git \
            --sync-source=https://code.aliyun.com/xiaozhou/tensorflow-sample-code.git \
            "python code/tensorflow-sample-code/tfjob/docker/mnist/main.py --max_steps 10000 --data_dir=code/tensorflow-sample-code/data"

   Catatan

   Dalam contoh ini, sumber daya GPU, CPU, dan memori dialokasikan ke grup pengguna dev2. Oleh karena itu, Tom harus menentukan sumber daya yang diminta oleh pekerjaan yang akan dikirimkan.

4. Jalankan perintah berikut untuk mengirimkan pekerjaan lain yang memerlukan satu GPU:

    arena submit tf \
            --name=tf-git-tom-02 \
            --gpus=1 \
            --chief-cpu=2 \
            --chief-memory=10Gi \
            --image=tensorflow/tensorflow:1.5.0-devel-gpu \
            --sync-mode=git \
            --sync-source=https://code.aliyun.com/xiaozhou/tensorflow-sample-code.git \
            "python code/tensorflow-sample-code/tfjob/docker/mnist/main.py --max_steps 10000 --data_dir=code/tensorflow-sample-code/data"

5. Jalankan perintah berikut untuk mendaftar semua pekerjaan yang dikirimkan oleh Tom:

   arena list

   Output yang Diharapkan:

   

Lihat hasilnya

Hasil di atas menunjukkan bahwa Anda dapat masuk ke klien dan menjalankan Arena di lingkungan terpisah dengan akun Bob dan Tom. Anda juga dapat menanyakan dan menggunakan sumber daya komputasi dan penyimpanan yang dialokasikan ke setiap grup pengguna, serta mengelola pekerjaan yang dikirimkan oleh Bob dan Tom.