Melakukan bootstrap node GKE secara otomatis dengan DaemonSets

Tutorial ini menunjukkan cara menyesuaikan node cluster Google Kubernetes Engine (GKE) menggunakan DaemonSets. DaemonSet membantu memastikan bahwa semua node (atau yang dipilih) menjalankan salinan Pod. Saat node baru ditambahkan ke cluster, node tersebut juga menjalankan Pod dari DaemonSet.

Jika alat dan sistem yang Anda gunakan untuk menginisialisasi cluster Anda berbeda dengan alat dan sistem yang Anda gunakan untuk menjalankan workload, Anda akan meningkatkan upaya yang diperlukan untuk mengelola lingkungan Anda. Misalnya, jika Anda menggunakan alat manajemen konfigurasi untuk melakukan inisialisasi node cluster, Anda mengandalkan prosedur yang berada di luar lingkungan runtime tempat sisa workload Anda berjalan. Dengan DaemonSet, Anda dapat menggunakan alat yang sama untuk mengatur workload yang Anda gunakan untuk mengubah node GKE.

Tujuan tutorial ini adalah untuk membantu administrator sistem, engineer sistem, atau operator infrastruktur menyederhanakan inisialisasi cluster Kubernetes.

Sebelum membaca halaman ini, pastikan Anda memahami:

Dalam tutorial ini, Anda akan mempelajari cara menggunakan taint dan toleransi Kubernetes untuk membantu memastikan bahwa node dikonfigurasi oleh DaemonSet sebelum beban kerja aplikasi dapat dijadwalkan di node tersebut.

Tujuan

Dalam tutorial ini, Anda akan melakukan beberapa hal berikut:

  • Sediakan cluster GKE.
  • Taint node pool untuk mencegah penjadwalan workload sebelum menerapkan konfigurasi node.
  • Deploy DaemonSet yang mengonfigurasi node dan menghapus taint.
  • Pastikan node cluster dikonfigurasi dan taint dihapus.

Biaya

Dalam dokumen ini, Anda akan menggunakan komponen Google Cloudyang dapat ditagih berikut:

Untuk membuat perkiraan biaya berdasarkan proyeksi penggunaan Anda, gunakan kalkulator harga.

Pengguna Google Cloud baru mungkin memenuhi syarat untuk mendapatkan uji coba gratis.

Setelah menyelesaikan tugas yang dijelaskan dalam dokumen ini, Anda dapat menghindari penagihan berkelanjutan dengan menghapus resource yang Anda buat. Untuk mengetahui informasi selengkapnya, baca bagian Pembersihan.

Sebelum memulai

  1. Login ke akun Google Cloud Anda. Jika Anda baru menggunakan Google Cloud, buat akun untuk mengevaluasi performa produk kami dalam skenario dunia nyata. Pelanggan baru juga mendapatkan kredit gratis senilai $300 untuk menjalankan, menguji, dan men-deploy workload.

  2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

  3. Verify that billing is enabled for your Google Cloud project.

  4. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

  5. Verify that billing is enabled for your Google Cloud project.

Implikasi keamanan DaemonSet yang memiliki hak istimewa

Penggunaan setelan securityContext: privileged: true di DaemonSet (atau Pod apa pun) sangat efektif, tetapi memiliki implikasi keamanan yang signifikan karena menonaktifkan sebagian besar batas isolasi container untuk Pod tersebut. Anda harus mengetahui batasan dan risiko keamanan berikut yang ditimbulkan oleh fitur ini:

  • Penyusupan host atau keluar dari container: kerentanan dalam aplikasi atau image container dengan hak istimewa dapat secara langsung menyebabkan akses root pada node host.
  • Pelanggaran hak istimewa terendah: mode istimewa memberikan semua kemampuan, kemungkinan jauh lebih banyak daripada yang diperlukan untuk tugas tertentu. Akses yang luas ini meningkatkan potensi kerusakan jika container disusupi.
  • Ketidakstabilan node: perintah yang tidak disengaja atau berbahaya dapat dijalankan dalam kontainer yang memiliki hak istimewa, misalnya nilai sysctl yang salah atau perintah seperti rm -rf /host/boot. Jenis perintah ini dapat menyebabkan node host mengalami error atau merusak sistem operasi.
  • Perpindahan lateral: mengkompromikan satu node melalui DaemonSet dengan hak istimewa memberi penyerang pijakan yang kuat untuk menyerang node lain, bidang kontrol Kubernetes, atau sistem yang terhubung.
  • Eksposur data: akses tanpa batas ke sistem file host (/) dapat mengekspos data sensitif yang disimpan di node, termasuk kredensial, kunci, atau data milik Pod lain jika mereka menggunakan volume hostPath.
  • Peningkatan permukaan serangan: mode istimewa mengekspos lebih banyak panggilan dan fitur sistem kernel host ke potensi eksploitasi dari dalam container.

Untuk menghindari risiko keamanan, Anda harus mengetahui praktik terbaik dan mitigasi berikut:

  • Hindari penggunaan mode hak istimewa: pendekatan yang paling aman adalah menghindari setelan privileged: true sepenuhnya.
  • Menggunakan kemampuan Linux: jika hak istimewa yang lebih tinggi diperlukan, Anda dapat memberikan kemampuan Linux tertentu seperti NET_ADMIN, SYS_ADMIN, SYS_MODULE di kolom securityContext.capabilities.add, bukan hak istimewa penuh. Pendekatan ini mengikuti prinsip hak istimewa terendah, yang kami rekomendasikan daripada memberikan izin yang luas.
  • Batasi cakupan: jalankan DaemonSet istimewa hanya di kumpulan node khusus yang mungkin terkontaminasi untuk membatasi potensi dampak jika container terkompromi.
  • Terapkan kebijakan: gunakan alat seperti Pengontrol Kebijakan atau Pemilah Komunikasi untuk membuat kebijakan yang membatasi, mengaudit, atau mewajibkan justifikasi untuk men-deploy container istimewa.
  • Pindai dan gunakan image tepercaya: gunakan Otorisasi Biner dan pemindaian image yang ketat untuk membantu memastikan hanya image container tepercaya yang telah diperiksa yang dijalankan dengan hak istimewa yang ditingkatkan.
  • Minimalkan pemasangan host: hanya pasang jalur host tertentu yang diperlukan, dan gunakan readOnly: true jika memungkinkan. Hindari memasang seluruh sistem file root (/).
  • Lakukan audit rutin: tinjau secara berkala semua workload yang berjalan dengan setelan privileged: true.

Melakukan bootstrap pada lingkungan

Di bagian ini, Anda akan melakukan hal berikut:

  1. Mengaktifkan Cloud API yang diperlukan.
  2. Menyediakan akun layanan dengan hak istimewa terbatas untuk node di cluster GKE.
  3. Menyiapkan cluster GKE.
  4. Memberikan hak istimewa administrasi cluster pengguna.

Aktifkan Cloud API

  1. Buka Cloud Shell.

    BUKA Cloud Shell

  2. Pilih project Google Cloud :

    gcloud config set project project-id

    Ganti project-id dengan ID projectGoogle Cloud yang Anda buat atau pilih untuk tutorial ini.

  3. Aktifkan Kubernetes Engine API:

    gcloud services enable container.googleapis.com

Menyediakan akun layanan untuk mengelola cluster GKE

Di bagian ini, Anda akan membuat akun layanan yang terkait dengan node dalam cluster. Dalam tutorial ini, node GKE menggunakan akun layanan ini, bukan akun layanan default. Sebagai praktik terbaik, cukup berikan akun layanan peran dan izin akses yang diperlukan untuk menjalankan aplikasi.

Peran yang diperlukan untuk akun layanan adalah sebagai berikut:

  • Peran Monitoring Viewer (roles/monitoring.viewer). Peran ini memberikan akses hanya baca ke data pemantauan.
  • Peran Penulis Metrik Pemantauan (roles/monitoring.metricWriter). Peran ini mengizinkan penulisan data pemantauan.
  • Peran Penulis Log (roles/logging.logWriter). Peran ini memberikan izin untuk menulis log.

Untuk menyediakan akun layanan, ikuti langkah-langkah berikut:

  1. Di Cloud Shell, lakukan inisialisasi variabel lingkungan yang menyimpan nama akun layanan:

    GKE_SERVICE_ACCOUNT_NAME=ds-init-tutorial-gke

  2. Membuat akun layanan

    gcloud iam service-accounts create "$GKE_SERVICE_ACCOUNT_NAME" \
  --display-name="$GKE_SERVICE_ACCOUNT_NAME"

  3. Lakukan inisialisasi variabel lingkungan yang menyimpan nama akun email akun layanan:

    GKE_SERVICE_ACCOUNT_EMAIL="$(gcloud iam service-accounts list \
    --format='value(email)' \
    --filter=displayName:"$GKE_SERVICE_ACCOUNT_NAME")"

  4. Ikat peran Identity and Access Management (IAM) ke akun layanan:

    gcloud projects add-iam-policy-binding \
    "$(gcloud config get-value project 2> /dev/null)" \
    --member serviceAccount:"$GKE_SERVICE_ACCOUNT_EMAIL" \
    --role roles/monitoring.viewer
gcloud projects add-iam-policy-binding \
    "$(gcloud config get-value project 2> /dev/null)" \
    --member serviceAccount:"$GKE_SERVICE_ACCOUNT_EMAIL" \
    --role roles/monitoring.metricWriter
gcloud projects add-iam-policy-binding \
    "$(gcloud config get-value project 2> /dev/null)" \
    --member serviceAccount:"$GKE_SERVICE_ACCOUNT_EMAIL" \
    --role roles/logging.logWriter

Menyiapkan cluster GKE

Di bagian ini, Anda akan meluncurkan cluster GKE, memberikan izin, dan menyelesaikan konfigurasi cluster.

Untuk tutorial ini, cluster dengan jumlah node kecil tujuan umum yang relatif rendah sudah cukup untuk mendemonstrasikan konsep tutorial ini. Anda membuat cluster dengan satu node pool (yang default).

  • Di Cloud Shell, buat dan luncurkan cluster GKE regional:

    gcloud container clusters create ds-init-tutorial \
    --enable-ip-alias \
    --machine-type=n1-standard-2 \
    --metadata disable-legacy-endpoints=true \
    --node-labels=app=default-init \
    --node-locations us-central1-a,us-central1-b,us-central1-c \
    --no-enable-basic-auth \
    --no-issue-client-certificate \
    --num-nodes=1 \
    --location us-central1 \
    --service-account="$GKE_SERVICE_ACCOUNT_EMAIL"

Menerapkan konfigurasi node menggunakan DaemonSet

Di bagian ini, Anda mencegah workload berjalan di node sebelum konfigurasi selesai dengan menerapkan taint ke kumpulan node. Kemudian, Anda men-deploy DaemonSet yang melakukan hal berikut:

  1. Menjadwalkan Pod pada node yang diberi taint dengan menggunakan toleransi untuk taint.
  2. Menjalankan container init istimewa yang pertama-tama menerapkan konfigurasi node menggunakan sysctl, lalu menghapus taint dari node menggunakan kubectl. Menghapus taint membuat node dapat dijadwalkan untuk workload.
  3. Menjadwalkan dan menjalankan container jeda yang tetap tidak ada aktivitas dan tidak menggunakan resource untuk mencegah DaemonSet menjadwalkan ulang Pod yang digunakan untuk konfigurasi.

Tutorial ini menerapkan parameter kernel vm.max_map_count=262144 sebagai contoh konfigurasi.

  1. Terapkan taint ke node pool default:

    gcloud container node-pools update default-pool \
  --cluster=ds-init-tutorial \
  --node-taints=node.config.status/stage=configuring:NoSchedule \
  --region=us-central1

    Dengan taint ini, hanya Pod yang menoleransinya, seperti Pod DaemonSet, yang dapat dijadwalkan di node pool ini.

  2. Pastikan taint diterapkan:

    kubectl describe nodes -l cloud.google.com/gke-nodepool=default-pool | grep Taints

    Status node harus menampilkan node.config.status/stage=configuring:NoSchedule.

  3. Simpan manifes berikut sebagai auto-untaint-daemonset.yaml:

    # WARNING: This DaemonSet runs as privileged, which has significant
# security implications. Only use this on clusters where you have
# strict controls over what is deployed.
---
apiVersion: v1
kind: ServiceAccount
metadata:
  name: node-config-sa
  namespace: default
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: node-patcher-role
rules:
- apiGroups: [""]
  resources: ["nodes"]
  # Permissions needed to read and remove a taint from the node.
  verbs: ["get", "patch", "update"]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: node-config-binding
subjects:
- kind: ServiceAccount
  name: node-config-sa
  namespace: default
roleRef:
  kind: ClusterRole
  name: node-patcher-role
  apiGroup: rbac.authorization.k8s.io
---
apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: auto-untaint-daemonset
  labels:
    app: auto-untaint-configurator
spec:
  selector:
    matchLabels:
      app: auto-untaint-configurator
  updateStrategy:
    type: RollingUpdate
  template:
    metadata:
      labels:
        app: auto-untaint-configurator
    spec:
      serviceAccountName: node-config-sa
      hostPID: true
      # Toleration now matches the taint on your node.
      tolerations:
      - key: "node.config.status/stage"
        operator: "Equal"
        value: "configuring"
        effect: "NoSchedule"
      volumes:
      - name: host-root-fs
        hostPath:
          path: /
      initContainers:
      - name: configure-and-untaint
        image: ubuntu:22.04 # Using a standard container image.
        securityContext:
          privileged: true # Required for chroot and sysctl.
        env:
        - name: NODE_NAME
          valueFrom:
            fieldRef:
              fieldPath: spec.nodeName
        volumeMounts:
        - name: host-root-fs
          mountPath: /host
        command: ["/bin/bash", "-c"]
        args:
        - |
          # Using explicit error checking for each critical command.

          # Define the configuration and taint details.
          SYSCTL_PARAM="vm.max_map_count"
          SYSCTL_VALUE="262144"
          TAINT_KEY="node.config.status/stage"

          echo "Running configuration on node: ${NODE_NAME}"

          # 1. APPLY CONFIGURATION
          echo "--> Applying ${SYSCTL_PARAM}=${SYSCTL_VALUE}..."
          if ! chroot /host sysctl -w "${SYSCTL_PARAM}=${SYSCTL_VALUE}"; then
            echo "ERROR: Failed to apply sysctl parameter." >&2
            exit 1
          fi
          echo "--> Configuration applied successfully."

          # 2. UNTAINT THE NODE
          # This command removes the taint from the node this Pod is running on.
          echo "--> Untainting node ${NODE_NAME} by removing taint ${TAINT_KEY}..."
          if ! /host/home/kubernetes/bin/kubectl taint node "${NODE_NAME}" "${TAINT_KEY}:NoSchedule-"; then
            echo "ERROR: Failed to untaint the node." >&2
            exit 1
          fi
          echo "--> Node has been untainted and is now schedulable."
      # The main container is minimal; it just keeps the Pod running.
      containers:
      - name: pause-container
        image: registry.k8s.io/pause:3.9

    Manifes ini membuat ServiceAccount, ClusterRole, dan ClusterRoleBinding untuk memberi DaemonSet izin untuk menghapus taint dari node. DaemonSet men-deploy Pod ke setiap node yang mentoleransi taint configuring:NoSchedule. Pod ini menjalankan container init dengan hak istimewa yang menerapkan konfigurasi sysctl (vm.max_map_count=262144) dan menghapus taint node, yang membuat node dapat dijadwalkan. Kemudian, container jeda akan dimulai untuk menjaga agar Pod tetap berjalan.

    Container init berjalan dalam mode istimewa, yang memiliki implikasi keamanan. Untuk mengetahui detail selengkapnya, lihat Trade-off dan batasan keamanan DaemonSet istimewa.

  4. Terapkan manifes:

    kubectl apply -f auto-untaint-daemonset.yaml

  5. Verifikasi bahwa Pod DaemonSet dibuat dan tunggu hingga mencapai status Running:

    kubectl get pods -l app=auto-untaint-configurator -o wide

    Status Running menunjukkan bahwa init container telah berhasil diselesaikan. Catat nama Pod agar Anda dapat menggunakannya untuk memverifikasi inisialisasi di bagian berikutnya.

Memvalidasi dan memverifikasi prosedur inisialisasi

Setelah konfigurasi node selesai, Anda dapat memverifikasi hasilnya dengan memeriksa log.

  1. Periksa log container init salah satu Pod untuk melihat outputnya:

    kubectl logs POD_NAME -c configure-and-untaint

    Ganti POD_NAME dengan nama Pod Anda.

    Anda akan melihat output yang menunjukkan konfigurasi berhasil dan penghapusan taint node.

  2. Pastikan taint telah dihapus:

    kubectl describe nodes -l cloud.google.com/gke-nodepool=default-pool | grep Taints

    Status node akan menampilkan Taints: <none>, atau menampilkan taint yang memiliki kunci node.config.status/stage.

Pembersihan

Agar akun Google Cloud Anda tidak dikenai biaya untuk resource yang digunakan dalam tutorial ini, Anda dapat menghapus project yang dibuat untuk tutorial ini. Jika membuat project khusus untuk tutorial ini, Anda dapat menghapusnya sepenuhnya. Jika Anda menggunakan project yang sudah ada, tetapi tidak ingin menghapusnya, gunakan langkah-langkah berikut untuk membersihkan project.

Membersihkan project

Untuk membersihkan project tanpa menghapusnya, Anda harus menghapus resource yang dibuat dalam tutorial ini.

  1. Di Cloud Shell, hapus cluster GKE:

    gcloud container clusters delete ds-init-tutorial --quiet --region us-central1

  2. Hapus akun layanan:

    gcloud iam service-accounts delete "$GKE_SERVICE_ACCOUNT_EMAIL" --quiet

Menghapus project

Cara termudah untuk menghilangkan penagihan adalah dengan menghapus project yang Anda buat untuk tutorial.

  1. Di Konsol Google Cloud , buka halaman Manage resources.

    Buka Kelola resource

  2. Pada daftar project, pilih project yang ingin Anda hapus, lalu klik Delete.
  3. Pada dialog, ketik project ID, lalu klik Shut down untuk menghapus project.

Langkah berikutnya