Menginstal penyedia Google Kubernetes Symphony

Untuk mengintegrasikan IBM Symphony dengan Google Kubernetes Engine (GKE) untuk pengelolaan resource dinamis, Anda harus menginstal dan mengonfigurasi penyedia Symphony untuk GKE. Penyedia ini memungkinkan Symphony menyediakan dan mengelola resource komputasi sebagai pod di cluster GKE Anda, sehingga memungkinkan penskalaan workload yang efisien melalui orkestrasi Kubernetes.

Untuk mengaktifkan integrasi ini, Anda menginstal operator Kubernetes di cluster, menginstal plugin penyedia di host utama Symphony, dan mengonfigurasi layanan factory host Symphony untuk berkomunikasi dengan GKE.

Untuk mengetahui informasi selengkapnya tentang Symphony Connectors untuk Google Cloud, lihat Mengintegrasikan IBM Spectrum Symphony dengan Google Cloud.

Sebelum memulai

Untuk menginstal penyedia Symphony untuk GKE, Anda harus memiliki resource berikut:

Cluster IBM Spectrum Symphony yang sedang berjalan dengan layanan host factory yang diaktifkan.
Cluster GKE yang sedang berjalan. Untuk membuatnya, lihat ringkasan GKE.
Akun layanan dengan izin yang sesuai. Lihat bagian Peran yang diperlukan untuk mengetahui detailnya.
Alat command line kubectl diinstal dan dikonfigurasi untuk berkomunikasi dengan cluster GKE Anda.

Peran yang diperlukan

Untuk mendapatkan izin yang Anda perlukan untuk menginstal operator dan mengelola pod Symphony, minta administrator Anda untuk memberi Anda peran IAM berikut di project Anda:

Untuk mengelola resource Kubernetes: Admin Kubernetes Engine (roles/container.admin)

Untuk mengetahui informasi selengkapnya tentang pemberian peran, lihat Mengelola akses ke project, folder, dan organisasi.

Anda mungkin juga bisa mendapatkan izin yang diperlukan melalui peran khusus atau peran bawaan lainnya.

Menginstal operator Kubernetes

Sebelum menginstal penyedia GKE, Anda harus menginstal operator Kubernetes terkait. Operator mengelola siklus proses pod komputasi Symphony dalam cluster GKE Anda.

Membangun image operator

Untuk membuat dan men-deploy manifes Kubernetes untuk operator, Anda harus mem-build image container operator terlebih dahulu. Manifes mencakup Definisi Resource Kustom (CRD) yang digunakan operator untuk mengelola Symphony. Untuk mendapatkan image, Anda dapat mem-build-nya dari sumber.

Untuk membuat image operator dari sumber, selesaikan langkah-langkah berikut:

Clone repositori symphony-gcp-connector dari GitHub:

git clone https://github.com/GoogleCloudPlatform/symphony-gcp-connector.git

Buka direktori k8s-operator:
```
cd symphony-gcp-connector/k8s-operator
```
Tetapkan variabel lingkungan untuk nama, registry, dan tag image:
```
export IMAGE="gcp-symphony-operator"
export REGISTRY="IMAGE_REPO"
export TAG="TAG"
```
Ganti kode berikut:
- IMAGE_REPO: repositori image tempat image operator disimpan. Misalnya, Anda dapat menggunakan Artifact Registry untuk menyimpan image operator. Untuk mengetahui informasi selengkapnya, lihat Membuat repositori Docker.
- TAG: tag untuk image operator, misalnya, 0.0.1.

Bangun dan kirim image operator:

bash -c 'docker buildx build --platform linux/amd64 -t $IMAGE:$TAG -t $IMAGE:latest -t $REGISTRY/$IMAGE:$TAG -t $REGISTRY/$IMAGE:latest .'
bash -c 'docker push $REGISTRY/$IMAGE:$TAG && docker push $REGISTRY/$IMAGE:latest'

Mengonfigurasi manifes operator

Setelah memiliki image operator, Anda perlu membuat dan mengonfigurasi manifes Kubernetes.

Untuk membuat manifes, gunakan perintah export-manifests dengan image operator:

docker run --rm gcp-symphony-operator:latest export-manifests > manifests.yaml

Buka file manifests.yaml di editor teks pilihan Anda.
Di bagian spec.template.spec.containers, temukan kolom image dan perbarui nilainya ke jalur lengkap gambar yang Anda kirim ke registry.
```
...
containers:
- image: IMAGE_REPO/gcp-symphony-operator:TAG
  name: manager
...
```
Ganti kode berikut:
- IMAGE_REPO: jalur ke repositori gambar tempat Anda mengirimkan gambar operator.
- TAG: tag yang Anda tetapkan ke image operator saat Anda membuatnya.
Opsional: Anda juga dapat mengubah nilai imagePullPolicy agar sesuai dengan praktik pengelolaan cluster Anda.

Terapkan manifes operator

Setelah mengonfigurasi manifes, terapkan ke cluster Kubernetes Anda. Anda dapat menerapkan manifes menggunakan kubectl atau Cluster Toolkit.

kubectl: Untuk menerapkan manifes menggunakan kubectl, jalankan perintah berikut:
```
kubectl apply -f manifests.yaml
```
Cluster Toolkit: Jika infrastruktur GKE Anda dikelola oleh Cluster Toolkit, tambahkan sumber modules/management/kubectl-apply ke cetak biru GKE Anda untuk menerapkan manifes. Berikut adalah contoh konfigurasi, dengan asumsi bahwa file manifests.yaml berada di direktori yang sama dengan blueprint GKE:
```
  -   id: symphony_operator_install
      source: modules/management/kubectl-apply
      use: [gke_cluster]
      settings:
      apply_manifests:
        -   source: $(ghpc_stage("manifests.yaml"))
```
Untuk mengetahui informasi selengkapnya, lihat ringkasan Cluster Toolkit.

Muat variabel lingkungan host factory

Sebelum dapat mengonfigurasi atau mengelola layanan factory host, Anda harus memuat variabel lingkungan Symphony ke dalam sesi shell. Di VM host utama Symphony, jalankan perintah berikut:

source INSTALL_FOLDER/profile.platform

Ganti INSTALL_FOLDER dengan jalur ke folder penginstalan Anda. Jalur folder penginstalan Symphony default adalah /opt/ibm/spectrumcomputing. Namun, jika Anda menginstal Symphony di tempat lain, Anda harus menggunakan jalur yang benar untuk lingkungan Anda.

Perintah ini menjalankan skrip profile.platform, yang mengekspor variabel lingkungan penting seperti $EGO_TOP dan $HF_TOP, serta menambahkan alat command line Symphony ke PATH shell Anda. Anda harus menjalankan perintah ini untuk setiap sesi terminal baru guna memastikan lingkungan dikonfigurasi dengan benar.

Menginstal plugin penyedia

Untuk mengintegrasikan penyedia GKE dengan host factory Symphony, instal plugin penyedia bawaan dari paket RPM atau buat penyedia dari kode sumber.

Menginstal plugin penyedia bawaan

Untuk menginstal plugin penyedia menggunakan paket RPM, ikuti langkah-langkah berikut di VM host utama Symphony Anda:

Tambahkan repositori yum untuk Google Cloud Symphony Connectors:

sudo tee /etc/yum.repos.d/google-cloud-symphony-connector.repo << EOM
[google-cloud-symphony-connector] name=Google Cloud Symphony Connector
baseurl=https://packages.cloud.google.com/yum/repos/google-cloud-symphony-connector-x86-64
enabled=1
gpgcheck=0
repo_gpgcheck=0
gpgkey=https://packages.cloud.google.com/yum/doc/yum-key.gpg
       https://packages.cloud.google.com/yum/doc/rpm-package-key.gpg
EOM

Instal paket penyedia untuk GKE:

sudo yum install -y hf-gcpgke-provider.x86_64

Penginstalan RPM secara otomatis menempatkan skrip dan file yang dapat dieksekusi penyedia di direktori yang benar untuk layanan factory host Symphony. Setelah penginstalan, struktur direktori untuk plugin penyedia akan muncul sebagai berikut untuk jalur $HF_TOP/$HF_VERSION/providerplugins/gcpgke:

├── bin
│   ├── hf-gke
│   └── README.md
└── scripts
    ├── getAvailableTemplates.sh
    ├── getRequestStatus.sh
    ├── getReturnRequests.sh
    ├── requestMachines.sh
    └── requestReturnMachines.sh

Membangun penyedia dari kode sumber

Untuk membuat dan menginstal file yang dapat dieksekusi CLI di direktori bin dari direktori plugin penyedia, ikuti langkah-langkah berikut:

Clone repositori symphony-gcp-connector dari GitHub:

git clone https://github.com/GoogleCloudPlatform/symphony-gcp-connector.git

Buka direktori hf-provider:
```
cd PROJECT_ROOT/hf-provider
```
Ganti PROJECT_ROOT dengan jalur ke direktori tingkat teratas yang berisi direktori hf-provider, seperti /home/user/symphony-gcp-connector.
Jika Anda belum menginstal uv, instal:
```
pip install uv
```
Buat lingkungan virtual Python menggunakan pengelola paket uvPython:
```
uv venv
```
Aktifkan lingkungan virtual:
```
source .venv/bin/activate
```
Instal dependensi project yang diperlukan:
```
uv pip install .
```
Instal PyInstaller, yang menggabungkan aplikasi Python ke dalam file yang dapat dieksekusi mandiri:
```
uv pip install pyinstaller
```
Buat CLI hf-gke untuk cluster Google Kubernetes Engine:
```
uv run pyinstaller hf-gke.spec --clean
```
Untuk memverifikasi penginstalan, jalankan perintah --help untuk file yang dapat dieksekusi. Anda mungkin melihat error jika tidak menyetel variabel lingkungan yang diperlukan.
```
dist/hf-gke --help
```

Jika Anda mem-build penyedia secara manual, buat direktori plugin penyedia untuk biner dan skrip:

mkdir -p $HF_TOP/$HF_VERSION/providerplugins/gcpgke/bin
mkdir -p $HF_TOP/$HF_VERSION/providerplugins/gcpgke/scripts

Salin biner dan skrip hf-gke ke direktori plugin penyedia. Biner hf-gke ada di direktori dist/ yang dibuat PyInstaller, dan skrip ada di direktori scripts/gcpgke/:
```
cp dist/hf-gke $HF_TOP/$HF_VERSION/providerplugins/gcpgke/bin/
cp scripts/gcpgke/* $HF_TOP/$HF_VERSION/providerplugins/gcpgke/scripts/
```
Setelah penginstalan, struktur direktori untuk plugin penyedia akan muncul sebagai berikut untuk jalur $HF_TOP/$HF_VERSION/providerplugins/gcpgke:

├── bin
│   └── hf-gke
└── scripts
    ├── getAvailableTemplates.sh
    ├── getRequestStatus.sh
    ├── getReturnRequests.sh
    ├── requestMachines.sh
    └── requestReturnMachines.sh

Aktifkan plugin penyedia

Untuk mengaktifkan plugin penyedia GKE, Anda harus mendaftarkannya dalam konfigurasi factory host.

Buka file ${HF_TOP}/conf/providerplugins/hostProviderPlugins.json.

Perintah source menentukan variabel lingkungan $HF_TOP di lingkungan Anda. Nilainya adalah jalur ke direktori penginstalan tingkat teratas untuk layanan host factory IBM Spectrum Symphony.

Tambahkan bagian plugin penyedia gcpgke:

{
    "name": "gcpgke",
    "enabled": 1,
    "scriptPath": "${HF_TOP}/${HF_VERSION}/providerplugins/gcpgke/scripts/"
}

Menyiapkan instance penyedia

Untuk mengonfigurasi penyedia GKE untuk lingkungan Anda, buat instance penyedia.

Jika Anda membangun konektor secara manual, buat direktori untuk instance penyedia, seperti: $HF_TOP/conf/providers/gcpgkeinst/.

Variabel lingkungan $HF_TOP ditentukan di lingkungan Anda jika Anda telah menggunakan profile.platform script. Nilainya adalah jalur ke direktori penginstalan tingkat teratas untuk layanan factory host IBM Spectrum Symphony.

Di direktori instance penyedia ($HF_TOP/conf/providers/gcpgkeinst/), buat atau konfigurasi file gcpgkeinstprov_config.json. File ini berisi konfigurasi utama untuk penyedia.

Jika menginstal plugin penyedia menggunakan paket RPM, Anda dapat menyalin file konfigurasi contoh, lalu menyesuaikannya:

cp $HF_TOP/conf/providers/gcpgkeinst/gcpgkeinstprov_config.json.dist $HF_TOP/conf/providers/gcpgkeinst/gcpgkeinstprov_config.json

Jika Anda membuat penyedia dari sumber, buat file gcpgkeinstprov_config.json.

Untuk file ini, biasanya Anda hanya perlu mengonfigurasi variabel GKE_KUBECONFIG, yang menentukan jalur ke file konfigurasi kubectl standar untuk cluster GKE terkait. Jika Anda tidak menentukan jalur, defaultnya adalah kubeconfig di direktori instance penyedia. Anda harus memastikan bahwa jalur ini mengarah ke file konfigurasi kubectl yang valid untuk cluster Kubernetes yang digunakan instance penyedia ini.

Berikut adalah contoh konfigurasi:

{
  "GKE_KUBECONFIG": "kubeconfig"
}

Variabel konfigurasi berikut didukung:

Nama Variabel	Deskripsi	Nilai Default
`GKE_KUBECONFIG`	Jalur ke file konfigurasi yang digunakan oleh perintah kubectl.	Tidak ada
`GKE_CRD_NAMESPACE`*	Menentukan namespace Kubernetes tempat semua resource dibuat.	`gcp-symphony`
`GKE_CRD_GROUP`*	Grup resource yang digunakan untuk mengidentifikasi resource kustom untuk operator factory host GKE.	`accenture.com`
`GKE_CRD_VERSION`*	Versi yang digunakan untuk mengidentifikasi resource kustom untuk operator factory host GKE.	`v1`
`GKE_CRD_KIND`*	Nama yang diberikan ke definisi resource kustom yang menentukan permintaan untuk resource komputasi (pod).	`GCP Symphony Resource`
`GKE_CRD_SINGULAR`*	Digunakan dalam panggilan API saat merujuk ke instance CR Google Cloud Symphony `Resource`.	`gcp-symphony-resource`
`GKE_CRD_RETURN_REQUEST_KIND`*	Nama yang diberikan ke definisi resource kustom yang menentukan permintaan untuk menampilkan resource komputasi (pod).	`Machine Return Request`
`GKE_CRD_RETURN_REQUEST_SINGULAR`*	Digunakan dalam panggilan API saat merujuk ke satu instance resource kustom `MachineReturnRequest`.	`machine-return-request`
`GKE_REQUEST_TIMEOUT`	Durasi, dalam detik, permintaan ke bidang kontrol GKE menunggu respons.	`300`
`LOG_LEVEL`	Mengontrol tingkat detail log yang ditulis penyedia GKE ke file log. Opsinya adalah `CRITICAL`, `WARNING`, `ERROR`, `INFO`, `DEBUG`.	`WARNING`

Dalam direktori yang sama, buat atau konfigurasi file gcpgkeinstprov_templates.json. File ini menentukan template untuk pod yang dapat dibuat oleh penyedia.

Jika Anda menginstal plugin penyedia menggunakan paket RPM, Anda dapat menyalin file template contoh, lalu menyesuaikannya:

cp $HF_TOP/conf/providers/gcpgkeinst/gcpgkeinstprov_templates.json.dist $HF_TOP/conf/providers/gcpgkeinst/gcpgkeinstprov_templates.json

Jika Anda membuat penyedia dari sumber, buat file gcpgkeinstprov_templates.json.

Atribut template harus selaras dengan resource dalam spesifikasi pod. Berikut adalah contoh template:

{
    "templates": [
        {
            "templateId": "template-gcp-01",
            "maxNumber": 5000,
            "attributes": {
                "type": [ "String", "X86_64" ],
                "ncores": [ "Numeric", "1" ],
                "ncpus": [ "Numeric", "1" ],
                "nram": [ "Numeric", "2048" ]
            },
            "podSpecYaml": "pod-specs/pod-spec.yaml"
        }
    ]
}

Di direktori yang sama, buat file kubeconfig yang merupakan file konfigurasi kubectl yang valid untuk cluster Kubernetes Anda.
Di direktori instance penyedia, buat atau edit file pod-spec.yaml. File ini berfungsi sebagai template yang menentukan spesifikasi untuk pod komputasi Symphony yang dibuat di cluster GKE Anda.

Pod yang dibuat dari spesifikasi ini berfungsi sebagai node komputasi dan memerlukan akses ke penginstalan Symphony. Akses ini dapat diberikan melalui image container, yang mencakup penginstalan Symphony, atau melalui pemasangan sistem file bersama yang berisi penginstalan. Saat startup, pod menggunakan akses ini untuk bergabung ke cluster Symphony.

Langkah-langkah untuk membuat file bergantung pada cara Anda menginstal penyedia:
- Jika Anda menginstal penyedia dari paket RPM, salin contoh file pod-spec.yaml.dist yang disertakan dalam penginstalan:
```
cp $HF_TOP/conf/providers/gcpgkeinst/pod-specs/pod-spec.yaml.dist
$HF_TOP/conf/providers/gcpgkeinst/pod-specs/pod-spec.yaml
```
- Jika Anda mem-build penyedia dari sumber, buat direktori pod-specs dan file pod-spec.yaml secara manual:
```
mkdir -p $HF_TOP/conf/providers/gcpgkeinst/pod-specs touch
$HF_TOP/conf/providers/gcpgkeinst/pod-specs/pod-spec.yaml
```

Setelah membuat file ini, pastikan direktori instance penyedia Anda tampak seperti berikut:

├── gcpgkeinstprov_config.json
├── gcpgkeinstprov_templates.json
├── kubeconfig
└── pod-specs
    └── pod-spec.yaml

Aktifkan instance penyedia

Untuk mengaktifkan instance penyedia, aktifkan di file konfigurasi factory host:

Buka file $HF_TOP/conf/providers/hostProviders.json.
Tambahkan bagian instance penyedia gcpgkeinst:
```
{
    "name": "gcpgkeinst",
    "enabled": 1,
    "plugin": "gcpgke",
    "confPath": "${HF_CONFDIR}/providers/gcpgkeinst/",
    "workPath": "${HF_WORKDIR}/providers/gcpgkeinst/",
    "logPath": "${HF_LOGDIR}/"
}
```
Anda tidak perlu mengganti variabel ${HF_CONFDIR}, ${HF_WORKDIR}, dan ${HF_LOGDIR} dalam konfigurasi ini karena variabel tersebut adalah variabel lingkungan standar yang otomatis ditentukan oleh lingkungan host factory IBM Spectrum Symphony.

Saat Anda mengonfigurasi sesi shell dengan menjalankan source command, skrip ini menetapkan variabel tersebut untuk mengarah ke subdirektori yang benar dalam penginstalan Symphony Anda. Layanan factory host kemudian menggunakan variabel ini untuk membuat jalur lengkap saat runtime.

Aktifkan instance pemohon

Untuk mengizinkan komponen Symphony tertentu menggunakan penyedia GKE untuk menyediakan resource, aktifkan komponen tersebut untuk pemohon tersebut.

Buka file $HF_TOP/conf/requestors/hostRequestors.json.
Di instance pemohon yang sesuai, tambahkan gcpgkeinst ke parameter providers:
```
"providers": ["gcpgkeinst"],
```
Nilai penyedia harus cocok dengan nama penyedia yang Anda gunakan di Aktifkan instance penyedia.

Mulai layanan factory host

Untuk menerapkan perubahan konfigurasi, mulai layanan pabrik host. Di VM host utama Symphony, login sebagai administrator cluster dan mulai layanan:

sed -i -e "s|MANUAL|AUTOMATIC|g" $EGO_ESRVDIR/esc/conf/services/hostfactory.xml
egosh user logon -u "SYMPHONY_USERNAME -x "SYMPHONY_PASSWORD
egosh service start HostFactory

Ganti kode berikut:

SYMPHONY_USERNAME: nama pengguna Symphony untuk autentikasi.
SYMPHONY_PASSWORD: sandi untuk pengguna Symphony.

Menguji konektor

Buat permintaan resource untuk menguji penyedia untuk GKE.

Untuk melakukannya, gunakan salah satu metode berikut:

GUI Symphony: Untuk mengetahui petunjuk tentang cara membuat permintaan resource menggunakan GUI Symphony, lihat Menjadwalkan permintaan dan pengembalian host cloud secara manual dalam dokumentasi IBM.

REST API: Untuk membuat permintaan resource menggunakan REST API, ikuti langkah-langkah berikut:

Temukan host dan port REST API host factory:

egosh client view REST_HOST_FACTORY_URL

Outputnya mirip dengan contoh ini:

CLIENT NAME: REST_HOST_FACTORY_URL
DESCRIPTION: http://sym2.us-central1-c.c.symphonygcp.internal:9080/platform/rest/hostfactory/
TTL        : 0
LOCATION   : 40531@10.0.0.33
USER       : Admin

CHANNEL INFORMATION:
CHANNEL             STATE
9                   CONNECTED

Untuk membuat permintaan resource menggunakan REST API, gunakan perintah berikut:
```
HOST=PRIMARY_HOST
PORT=PORT
TEMPLATE_NAME=SYMPHONY_TEMPLATE_ID
PROVIDER_NAME=gcpgkeinst

curl -X POST -u "SYMPHONY_USER:SYMPHONY_PASSWORD" -H "Content-Type: application/json" -d "{ \"demand_hosts\": [ { \"prov_name\": \"$PROVIDER_NAME\", \"template_name\": \"$TEMPLATE_NAME\", \"ninstances\": 1 } ] }" \
http://$HOST:$PORT/platform/rest/hostfactory/requestor/admin/request
```
Ganti kode berikut:
- PRIMARY_HOST: nama host utama dari output perintah sebelumnya.
- PORT: nomor port host utama Anda dari output perintah sebelumnya, seperti 9080.
- SYMPHONY_TEMPLATE_ID: templateId yang ditentukan dalam file gcpgkeinstprov_templates.json, seperti template-gcp-01.
- SYMPHONY_USER: pengguna Symphony untuk autentikasi.
- SYMPHONY_PASSWORD: sandi untuk pengguna Symphony.
Jika berhasil, output-nya akan mirip dengan contoh ini:
```
{"scheduled_request_id":["SD-641ef442-1f9e-40ae-ae16-90e152ed60d2"]}
```

Langkah berikutnya

Memecahkan masalah konektor IBM Spectrum Symphony