Jak spustit MongoDB na Kubernetes

Úvod

MongoDB je univerzální databázový program NoSQL založený na dokumentech. Stejně jako u jiných nerelačních systémů pro správu databází se MongoDB zaměřuje na škálovatelnost a rychlost dotazů.

Kubernetes spolupracuje s MongoDB a vytváří vysoce škálovatelná a přenosná databázová nasazení. Tato nasazení jsou užitečná pro práci s velkým množstvím dat a vysokým zatížením.

Tento tutoriál vás naučí, jak nasadit MongoDB na Kubernetes. Průvodce obsahuje kroky ke spuštění samostatné instance MongoDB a sady replik.

Požadavky

• Cluster Kubernetes s kubectl.
• Administrativní přístup k vašemu systému.

Nasaďte samostatnou instanci MongoDB

MongoDB lze nasadit na Kubernetes jako samostatnou instanci. Toto nasazení není adekvátní pro produkční použití, ale je vhodné pro testování a některé aspekty vývoje.

Chcete-li nasadit samostatnou instanci MongoDB, postupujte podle následujících kroků.

Krok 1:Označení uzlu

Označte uzel, který bude použit pro nasazení MongoDB. Štítek se později použije k přiřazení podů ke konkrétnímu uzlu.

Postup:

1. Seznam uzlů ve vašem clusteru:

kubectl get nodes

2. Vyberte uzel nasazení ze seznamu ve výstupu příkazu.

3. Pomocí kubectl označte uzel párem klíč–hodnota.

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

Výstup potvrdí, že štítek byl úspěšně přidán.

Krok 2:Vytvořte StorageClass

StorageClass pomáhá modulům poskytovat trvalé nároky na objem na uzlu. Chcete-li vytvořit StorageClass:

1. Pomocí textového editoru vytvořte soubor YAML pro uložení konfigurace třídy úložiště.

nano StorageClass.yaml

2. V souboru zadejte konfiguraci vaší třídy úložiště. Níže uvedený příklad definuje mongodb-storageclass :

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

3. Uložte změny a ukončete editor.

Krok 3:Vytvořte trvalé úložiště

Poskytněte úložiště pro nasazení MongoDB vytvořením trvalého svazku a trvalého nároku na svazek:

1. Vytvořte soubor YAML pro trvalou konfiguraci svazku.

nano PersistentVolume.yaml

2. V souboru přidělte úložiště, které patří do třídy úložiště definované v předchozím kroku. Určete uzel, který bude použit při nasazení podu v nodeAffinity sekce. Uzel je identifikován pomocí štítku vytvořeného v kroku 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. Vytvořte další YAML pro konfiguraci trvalého nároku na svazek:

nano PersistentVolumeClaim.yaml

4. Definujte požadavek s názvem mongodb-pvc a instruovat Kubernetes, aby si nárokoval svazky patřící do mongodb-storageclass .

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

Krok 4:Vytvořte mapu ConfigMap

Soubor ConfigMap ukládá nešifrované konfigurační informace používané moduly.

1. Vytvořte soubor YAML pro uložení konfigurace nasazení:

nano ConfigMap.yaml

2. Použijte soubor k uložení informací o systémových cestách, uživatelích a rolích. Následuje příklad souboru 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;
          }
        }
      });

Krok 5:Vytvořte StatefulSet

StatefulSet je řadič Kubernetes používaný k nasazení stavových aplikací. Stavové moduly aplikací vyžadují jedinečné identity, protože komunikují s ostatními moduly.

Chcete-li vytvořit StatefulSet :

1. Pomocí textového editoru vytvořte soubor YAML:

nano StatefulSet.yaml

2. Do souboru vložte informace o nasazení, včetně obrazu MongoDB Docker, který se má použít. Soubor také odkazuje na dříve vytvořenou ConfigMap a 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

Krok 6:Vytvořte tajemství

Objekt Secret se používá k ukládání citlivých informací o nasazení.

1. Pomocí textového editoru vytvořte tajný YAML.

nano Secret.yaml

2. Poskytněte informace pro přístup k databázi 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. Uložte změny a ukončete.

Krok 7:Vytvořte službu MongoDB

Chcete-li vytvořit službu MongoDB:

1. Vytvořte objekt služby bez hlavy.

nano Service.yaml

Bezhlavá služba umožňuje uživatelům připojit se k modulům přímo.

2. Přidejte název služby a definici do souboru YAML.

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

3. Uložte změny a ukončete soubor.

Krok 8:Použijte konfiguraci MongoDB pomocí Kustomize

Pomocí Kustomize snadno aplikujte konfigurační soubory MongoDB:

1. Vytvořte kustomization.yaml soubor:

nano kustomization.yaml

2. V resources sekce, vypište všechny soubory YAML vytvořené v předchozích krocích:

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

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

Uložte soubor do stejného adresáře jako ostatní soubory.

3. Nasaďte MongoDB pomocí následujícího příkazu:

kubectl apply -k .

4. Pomocí kubectl zkontrolujte, zda je modul připraven.

kubectl get pod

Když modul zobrazuje 1/1 v READY přejděte k dalšímu kroku.

Krok 9:Připojte se k samostatné instanci MongoDB

1. Připojte se k modulu MongoDB pomocí následujícího příkazu kubectl:

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

2. Když # zobrazí se výzva, zadejte:

mongo

Načte se prostředí MongoDB.

3. Přepněte do testovací databáze:

use test

4. Proveďte ověření pomocí následujícího příkazu:

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

Číslo 1 ve výstupu potvrzuje úspěšnou autentizaci.

Nasazení sady ReplicaSet

Nasazení MongoDB jako ReplicaSet zajišťuje, že v daný čas běží zadaný počet modulů. Nasazení ReplicaSet se doporučují pro produkční prostředí.

Krok 1:Nastavení řízení přístupu založeného na rolích (RBAC)

Povolení řízení přístupu na základě rolí je jedním z osvědčených postupů zabezpečení Kubernetes. RBAC zajišťuje, že žádný uživatel nemá více oprávnění, než potřebuje.

Chcete-li nastavit RBAC:

1. Vytvořte soubor YAML pomocí textového editoru.

nano rbac.yaml

2. Poskytněte pravidla přístupu pro vaše nasazení MongoDB. Níže uvedený příklad ukazuje soubor 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. Uložte soubor a použijte jej pomocí kubectl:

kubectl apply -f rbac.yaml

Krok 2:Vytvoření StatefulSet Deployment

1. Vytvořte nasazení StatefulSet YAML:

nano StatefulSet.yaml

2. Zadejte počet replik v souboru, obraz MongoDB Docker, který se má použít, a poskytněte šablonu nároku na svazek pro poskytování dynamického svazku:

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. Uložte soubor a pomocí aplikace kubectl vytvořte rozmístění:

kubectl apply -f StatefulSet.yaml

Krok 3:Vytvořte bezhlavou službu

Chcete-li vytvořit službu bez hlavy:

1. Vytvořte soubor YAML služby:

nano Service.yaml

2. Definujte službu, která umožňuje přímou komunikaci s moduly:

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

3. Aplikujte YAML pomocí kubectl.

kubectl apply -f Service.yaml

Krok 4:Nastavení hostitele replikace

Postup nastavení replikace pod:

1. Zadejte pod pomocí kubectl exec :

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

Zobrazí se uvítací zpráva prostředí MongoDB.

2. Spusťte replikaci zadáním následujícího příkazu do příkazového řádku prostředí MongoDB:

rs.initiate()

"ok" : 1 řádek ukazuje, že iniciace byla úspěšná.

3. Definujte proměnnou s názvem cfg . Proměnná provede rs.conf() .

var cfg = rs.conf()

4. Pomocí proměnné přidejte primární server do konfigurace:

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

Výstup zobrazuje název primárního serveru.

5. Potvrďte konfiguraci provedením následujícího příkazu:

rs.reconfig(cfg)

"ok" : 1 řádek potvrzuje, že konfigurace byla úspěšná.

6. Použijte rs.add() příkaz pro přidání dalšího modulu do konfigurace.

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

Výstup ukazuje, že byla přidána replika.

7. Zkontrolujte stav systému zadáním:

rs.status()

"members" sekce by měla zobrazovat dvě repliky. Primární replika je uvedena v horní části výstupu.

Sekundární replika je pod primární replikou.

Nasazení ReplicaSet MongoDB je nastaveno a připraveno k provozu.