GNU/Linux >> Belajar Linux >  >> Linux

Cara Menjalankan MongoDB di Kubernetes

Pendahuluan

MongoDB adalah program database NoSQL berbasis dokumen untuk tujuan umum. Seperti halnya sistem manajemen basis data non-relasional lainnya, MongoDB berfokus pada skalabilitas dan kecepatan kueri.

Kubernetes bersinergi dengan MongoDB untuk membuat penerapan basis data yang sangat skalabel dan portabel. Penerapan ini berguna untuk bekerja dengan sejumlah besar data dan beban tinggi.

Tutorial ini akan mengajari Anda cara men-deploy MongoDB di Kubernetes. Panduan ini mencakup langkah-langkah untuk menjalankan instance MongoDB mandiri dan set replika.

Persyaratan

  • Kluster Kubernetes dengan kubectl.
  • Akses administratif ke sistem Anda.

Menerapkan Instans MongoDB Mandiri

MongoDB dapat di-deploy di Kubernetes sebagai instance mandiri. Penerapan ini tidak memadai untuk penggunaan produksi, tetapi cocok untuk pengujian dan beberapa aspek pengembangan.

Ikuti langkah-langkah di bawah ini untuk menerapkan instans MongoDB mandiri.

Langkah 1:Labeli Node

Beri label node yang akan digunakan untuk penyebaran MongoDB. Label tersebut digunakan kemudian untuk menetapkan pod ke node tertentu.

Untuk melakukannya:

1. Buat daftar node di cluster Anda:

kubectl get nodes

2. Pilih node penerapan dari daftar di output perintah.

3. Gunakan kubectl untuk memberi label pada node dengan pasangan nilai kunci.

kubectl label nodes <node> <key>=<value>

Keluaran mengonfirmasi bahwa label berhasil ditambahkan.

Langkah 2:Buat Kelas Penyimpanan

StorageClass membantu pod menyediakan klaim volume persisten pada node. Untuk membuat StorageClass:

1. Gunakan editor teks untuk membuat file YAML untuk menyimpan konfigurasi kelas penyimpanan.

nano StorageClass.yaml

2. Tentukan konfigurasi kelas penyimpanan Anda dalam file. Contoh di bawah mendefinisikan mongodb-storageclass :

kind: StorageClass
apiVersion: storage.k8s.io/v1
metadata:
  name: mongodb-storageclass
provisioner: kubernetes.io/no-provisioner
volumeBindingMode: WaitForFirstConsumer
allowVolumeExpansion: true

3. Simpan perubahan dan keluar dari editor.

Langkah 3:Buat Penyimpanan Persisten

Menyediakan penyimpanan untuk penerapan MongoDB dengan membuat volume persisten dan klaim volume persisten:

1. Buat file YAML untuk konfigurasi volume persisten.

nano PersistentVolume.yaml

2. Dalam file, alokasikan penyimpanan yang termasuk dalam kelas penyimpanan yang ditentukan pada langkah sebelumnya. Tentukan node yang akan digunakan dalam penerapan pod di nodeAffinity bagian. Node diidentifikasi menggunakan label yang dibuat di Langkah 1 .

apiVersion: v1
kind: PersistentVolume
metadata:
    name: mongodb-pv
spec:
  capacity:
    storage: 2Gi
  volumeMode: Filesystem
  accessModes:
    - ReadWriteOnce
  persistentVolumeReclaimPolicy: Retain
  storageClassName: mongodb-storageclass
  local:
    path: /mnt/data
  nodeAffinity:
    required:
      nodeSelectorTerms:
      - matchExpressions:
        - key: size
          operator: In
          values:
            - large

3. Buat YAML lain untuk konfigurasi klaim volume persisten:

nano PersistentVolumeClaim.yaml

4. Tentukan klaim bernama mongodb-pvc dan menginstruksikan Kubernetes untuk mengklaim volume milik mongodb-storageclass .

kind: PersistentVolumeClaim
apiVersion: v1
metadata:
  name: mongodb-pvc
spec:
  storageClassName: mongodb-storageclass
  accessModes:
    - ReadWriteOnce
  volumeMode: Filesystem
  resources:
    requests:
      storage: 1Gi

Langkah 4:Buat ConfigMap

File ConfigMap menyimpan informasi konfigurasi yang tidak terenkripsi yang digunakan oleh pod.

1. Buat file YAML untuk menyimpan konfigurasi penerapan:

nano ConfigMap.yaml

2. Gunakan file untuk menyimpan informasi tentang jalur sistem, pengguna, dan peran. Berikut ini adalah contoh file ConfigMap:

apiVersion: v1
kind: ConfigMap
metadata:
  name: mongodb-configmap
data:
  mongo.conf: |
    storage:
      dbPath: /data/db
  ensure-users.js: |
    const targetDbStr = 'test';
    const rootUser = cat('/etc/k8-test/admin/MONGO_ROOT_USERNAME');
    const rootPass = cat('/etc/k8-test/admin/MONGO_ROOT_PASSWORD');
    const usersStr = cat('/etc/k8-test/MONGO_USERS_LIST');

    const adminDb = db.getSiblingDB('admin');
    adminDb.auth(rootUser, rootPass);
    print('Successfully authenticated admin user');

    const targetDb = db.getSiblingDB(targetDbStr);

    const customRoles = adminDb
      .getRoles({rolesInfo: 1, showBuiltinRoles: false})
      .map(role => role.role)
      .filter(Boolean);

    usersStr
      .trim()
      .split(';')
      .map(s => s.split(':'))
      .forEach(user => {
        const username = user[0];
        const rolesStr = user[1];
        const password = user[2];

        if (!rolesStr || !password) {
          return;
        }

        const roles = rolesStr.split(',');
        const userDoc = {
          user: username,
          pwd: password,
        };

        userDoc.roles = roles.map(role => {
          if (!~customRoles.indexOf(role)) {
            return role;
          }
          return {role: role, db: 'admin'}; 
        });

        try {
          targetDb.createUser(userDoc);
        } catch (err) {
          if (!~err.message.toLowerCase().indexOf('duplicate')) {
            throw err;
          }
        }
      });

Langkah 5:Buat StatefulSet

StatefulSet adalah pengontrol Kubernetes yang digunakan untuk men-deploy aplikasi stateful. Pod aplikasi stateful memerlukan identitas unik karena mereka berkomunikasi dengan pod lain.

Untuk Membuat StatefulSet :

1. Gunakan editor teks untuk membuat file YAML:

nano StatefulSet.yaml

2. Masukkan informasi penerapan dalam file, termasuk gambar Docker MongoDB yang akan digunakan. File juga merujuk ke ConfigMap yang dibuat sebelumnya dan PersistentVolumeClaim :

apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: mongodb-test
spec:
  serviceName: mongodb-test
  replicas: 1
  selector:
    matchLabels:
      app: database
  template:
    metadata:
      labels:
        app: database
        selector: mongodb-test
    spec:
      containers:
      - name: mongodb-test
        image: mongo:4.0.8
        env:
          - name: MONGO_INITDB_ROOT_USERNAME_FILE
            value: /etc/k8-test/admin/MONGO_ROOT_USERNAME
          - name: MONGO_INITDB_ROOT_PASSWORD_FILE
            value: /etc/k8-test/admin/MONGO_ROOT_PASSWORD
        volumeMounts:
        - name: k8-test
          mountPath: /etc/k8-test
          readOnly: true
        - name: mongodb-scripts
          mountPath: /docker-entrypoint-initdb.d
          readOnly: true
        - name: mongodb-configmap
          mountPath: /config
          readOnly: true
        - name: mongodb-data
          mountPath: /data/db
      nodeSelector:
        size: large
      volumes:
      - name: k8-test
        secret:
          secretName: mongodb-secret
          items:
          - key: MONGO_ROOT_USERNAME
            path: admin/MONGO_ROOT_USERNAME
            mode: 0444
          - key: MONGO_ROOT_PASSWORD
            path: admin/MONGO_ROOT_PASSWORD
            mode: 0444
          - key: MONGO_USERNAME
            path: MONGO_USERNAME
            mode: 0444
          - key: MONGO_PASSWORD
            path: MONGO_PASSWORD
            mode: 0444
          - key: MONGO_USERS_LIST
            path: MONGO_USERS_LIST
            mode: 0444
      - name: mongodb-scripts
        configMap:
          name: mongodb-configmap
          items:
          - key: ensure-users.js
            path: ensure-users.js
      - name: mongodb-configmap
        configMap:
          name: mongodb-configmap
          items:
          - key: mongo.conf
            path: mongo.conf
      - name: mongodb-data
        persistentVolumeClaim:
          claimName: mongodb-pvc

Langkah 6:Buat Rahasia

Objek Rahasia digunakan untuk menyimpan informasi sensitif tentang penerapan.

1. Buat YAML Rahasia dengan editor teks Anda.

nano Secret.yaml

2. Memberikan informasi untuk mengakses database MongoDB.

apiVersion: v1
kind: Secret
metadata:
  name: mongodb-secret
type: Opaque
data:
  MONGO_ROOT_USERNAME: YWRtaW4K
  MONGO_ROOT_PASSWORD: cGFzc3dvcmQK
  MONGO_USERNAME: dGVzdAo=
  MONGO_PASSWORD: cGFzc3dvcmQK
  MONGO_USERS_LIST: dGVzdDpkYkFkbWluLHJlYWRXcml0ZTpwYXNzd29yZAo=

3. Simpan perubahan dan keluar.

Langkah 7:Buat Layanan MongoDB

Untuk membuat Layanan MongoDB:

1. Buat objek layanan tanpa kepala. 

nano Service.yaml

Layanan tanpa kepala memungkinkan pengguna terhubung ke pod secara langsung.

2. Tambahkan nama dan definisi layanan di file YAML.

apiVersion: v1
kind: Service
metadata:
  name: mongodb-test
  labels:
    app: database
spec:
  clusterIP: None
  selector:
    app: database

3. Simpan perubahan dan keluar dari file.

Langkah 8:Terapkan Konfigurasi MongoDB dengan Kustomize

Gunakan Kustomize untuk menerapkan file konfigurasi MongoDB dengan mudah:

1. Buat kustomization.yaml berkas:

nano kustomization.yaml

2. Di resources bagian, daftar semua file YAML yang dibuat pada langkah sebelumnya:

apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization

resources:
  - ConfigMap.yaml
  - PersistentVolumeClaim.yaml
  - PersistentVolume.yaml
  - Secret.yaml
  - Service.yaml
  - StatefulSet.yaml
  - StorageClass.yaml

Simpan file di direktori yang sama dengan file lainnya.

3. Deploy MongoDB dengan perintah berikut:

kubectl apply -k .

4. Gunakan kubectl untuk memeriksa apakah pod sudah siap.

kubectl get pod

Saat pod menunjukkan 1/1 di READY kolom, lanjutkan ke langkah berikutnya.

Langkah 9:Hubungkan ke Instans Mandiri MongoDB

1. Hubungkan ke pod MongoDB dengan menggunakan perintah kubectl berikut:

kubectl exec -it mongodb-test-0 -- sh

2. Saat # muncul prompt, ketik:

mongo

Shell MongoDB dimuat.

3. Beralih ke database pengujian:

use test

4. Otentikasi dengan perintah berikut:

db.auth('[username]','[password]')

Nomor 1 di output mengonfirmasi otentikasi yang berhasil.

Menerapkan ReplicaSet

Menyebarkan MongoDB sebagai ReplicaSet memastikan bahwa jumlah pod yang ditentukan berjalan pada waktu tertentu. Penerapan ReplicaSet direkomendasikan untuk lingkungan produksi.

Langkah 1:Siapkan Kontrol Akses Berbasis Peran (RBAC)

Mengaktifkan kontrol akses berbasis peran adalah salah satu praktik terbaik keamanan Kubernetes. RBAC memastikan bahwa tidak ada pengguna yang memiliki izin lebih dari yang dibutuhkan.

Untuk menyiapkan RBAC:

1. Buat file YAML dengan editor teks.

nano rbac.yaml

2. Berikan aturan akses untuk penerapan MongoDB Anda. Contoh di bawah ini menunjukkan file RBAC YAML:

apiVersion: v1
kind: ServiceAccount
metadata:
  name: mongo-account
  namespace: default
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: mongo-role
rules:
- apiGroups: [""]
  resources: ["configmaps"]
  verbs: ["*"]
- apiGroups: [""]
  resources: ["deployments"]
  verbs: ["list", "watch"]
- apiGroups: [""]
  resources: ["services"]
  verbs: ["*"]
- apiGroups: [""]
  resources: ["pods"]
  verbs: ["get","list", "watch"]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: mongo_role_binding
subjects:
- kind: ServiceAccount
  name: mongo-account
  namespace: default
roleRef:
  kind: ClusterRole
  name: mongo-role
  apiGroup: rbac.authorization.k8s.io

3. Simpan file dan terapkan dengan kubectl:

kubectl apply -f rbac.yaml

Langkah 2:Buat Penerapan StatefulSet

1. Buat YAML penerapan StatefulSet:

nano StatefulSet.yaml

2. Tentukan jumlah replika dalam file, gambar Docker MongoDB yang akan digunakan, dan sediakan template klaim volume untuk penyediaan volume dinamis:

apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: mongodb-replica
  namespace: default
spec:
  serviceName: mongo
  replicas: 2
  selector:
    matchLabels:
      app: mongo
  template:
    metadata:
      labels:
        app: mongo
        selector: mongo
    spec:
      terminationGracePeriodSeconds: 30
      serviceAccount: mongo-account
      containers:
      - name: mongodb
        image: docker.io/mongo:4.2
        env:
        command: ["/bin/sh"]
        args: ["-c", "mongod --replSet=rs0 --bind_ip_all"]
        resources:
          limits:
            cpu: 1
            memory: 1500Mi
          requests:
            cpu: 1
            memory: 1000Mi
        ports:
        - name: mongo-port
          containerPort: 27017
        volumeMounts:
        - name: mongo-data
          mountPath: /data/db
  volumeClaimTemplates:
  - metadata:
      name: mongo-data
    spec:
      accessModes:
        - ReadWriteOnce
      resources:
        requests:
          storage: 10Gi

3. Simpan file dan gunakan kubectl apply untuk membuat penerapan:

kubectl apply -f StatefulSet.yaml

Langkah 3:Buat Layanan Tanpa Kepala

Untuk membuat layanan tanpa kepala:

1. Buat file YAML layanan:

nano Service.yaml

2. Tentukan layanan yang memungkinkan komunikasi langsung dengan pod:

apiVersion: v1
kind: Service
metadata:
  name: mongo
  namespace: default
  labels:
    name: mongo
spec:
  ports:
    - port: 27017
      targetPort: 27017
  clusterIP: None
  selector:
    app: mongo

3. Terapkan YAML dengan kubectl.

kubectl apply -f Service.yaml

Langkah 4:Siapkan Host Replikasi

Untuk menyiapkan replikasi pod:

1. Masukkan pod menggunakan kubectl exec :

kubectl exec -it mongodb-replica-0 -n default -- mongo

Pesan sambutan shell MongoDB muncul.

2. Mulai replikasi dengan mengetikkan perintah berikut pada prompt shell MongoDB:

rs.initiate()

"ok" : 1 baris menunjukkan bahwa inisiasi berhasil.

3. Tentukan variabel yang disebut cfg . Variabel mengeksekusi rs.conf() .

var cfg = rs.conf()

4. Gunakan variabel untuk menambahkan server utama ke konfigurasi:

cfg.members[0].host="mongodb-replica-0.mongo:27017"

Keluaran menunjukkan nama server utama.

5. Konfirmasikan konfigurasi dengan menjalankan perintah berikut:

rs.reconfig(cfg)

"ok" : 1 baris mengkonfirmasi konfigurasi berhasil.

6. Gunakan rs.add() perintah untuk menambahkan pod lain ke konfigurasi.

rs.add("mongodb-replica-1.mongo:27017")

Keluaran menunjukkan replika telah ditambahkan.

7. Periksa status sistem dengan mengetik:

rs.status()

"members" bagian harus menunjukkan dua replika. Replika utama tercantum di bagian atas output.

Replika sekunder berada di bawah replika utama.

Penerapan ReplicaSet dari MongoDB telah disiapkan dan siap untuk dioperasikan.


Linux

  1. Cara men-deploy pod pertama Anda di Cluster Kubernetes

  2. Cara membuat Tag Git

  3. Bagaimana Menjalankan Skrip??

  1. Cara Membuat Database &Koleksi di MongoDB

  2. Cara Memulai Ulang Pod Kubernetes

  3. Cara Mengatur dan Menjalankan Kafka di Kubernetes

  1. Cara Membuat File di Linux

  2. Cara Membuat File Tar Gz

  3. Cara membuat modul Terraform