रूक को या रूक को नहीं - यही सवाल है

इस महीने की शुरुआत में, 3 मई को, "कुबेरनेट्स में वितरित डेटा भंडारण के लिए प्रबंधन प्रणाली" की एक बड़ी रिलीज की घोषणा की गई थी - रूक 1.0.0. एक वर्ष से अधिक समय पहले ही हम प्रकाशित रूक का सामान्य अवलोकन। फिर हमसे उनके अनुभव के बारे में बात करने को कहा गया व्यवहार में प्रयोग करें - और अब, परियोजना के इतिहास में इतने महत्वपूर्ण मील के पत्थर के ठीक समय पर, हम अपने संचित अनुभवों को साझा करने में प्रसन्न हैं।

संक्षेप में, रूक एक समुच्चय है ऑपरेटरों कुबेरनेट्स के लिए, जो सेफ, एजएफएस, मिनिओ, कैसेंड्रा, कॉकरोचडीबी जैसे डेटा भंडारण समाधानों की तैनाती, प्रबंधन, स्वचालित पुनर्प्राप्ति का पूर्ण नियंत्रण लेता है।

फिलहाल सबसे विकसित (और एकमात्र в स्थिर स्टेज) समाधान है रूक-सेफ-ऑपरेटर.

नोट: सेफ से संबंधित रूक 1.0.0 रिलीज में महत्वपूर्ण बदलावों के बीच, हम सेफ नॉटिलस के लिए समर्थन और सेफएफएस या आरजीडब्ल्यू बकेट के लिए एनएफएस का उपयोग करने की क्षमता को नोट कर सकते हैं। दूसरों के बीच जो बात सबसे अलग है वह है एजएफएस सपोर्ट का बीटा स्तर पर परिपक्व होना।

तो, इस लेख में हम:

• आइए इस प्रश्न का उत्तर दें कि कुबेरनेट्स क्लस्टर में सेफ को तैनात करने के लिए रूक का उपयोग करने में हमें क्या फायदे मिलते हैं;
• हम उत्पादन में रूक का उपयोग करने के अपने अनुभव और छापों को साझा करेंगे;
• आइए आपको बताएं कि हम रूक को "हां!" क्यों कहते हैं, और उसके लिए हमारी योजनाओं के बारे में।

आइए सामान्य अवधारणाओं और सिद्धांत से शुरू करें।

"मुझे एक रूक का फायदा है!" (अज्ञात शतरंज खिलाड़ी)

रूक का एक मुख्य लाभ यह है कि डेटा स्टोर के साथ बातचीत कुबेरनेट्स तंत्र के माध्यम से की जाती है। इसका मतलब यह है कि अब आपको शीट से कंसोल में सेफ को कॉन्फ़िगर करने के लिए कमांड को कॉपी करने की आवश्यकता नहीं है।

— क्या आप CephFS को क्लस्टर में तैनात करना चाहते हैं? बस एक YAML फ़ाइल लिखें!
- क्या? क्या आप भी S3 API के साथ एक ऑब्जेक्ट स्टोर तैनात करना चाहते हैं? बस दूसरी YAML फ़ाइल लिखें!

Rook एक विशिष्ट ऑपरेटर के सभी नियमों के अनुसार बनाया जाता है। उसके साथ बातचीत का उपयोग होता है सीआरडी (कस्टम संसाधन परिभाषाएँ), जिसमें हम सेफ संस्थाओं की उन विशेषताओं का वर्णन करते हैं जिनकी हमें आवश्यकता है (चूँकि यह एकमात्र स्थिर कार्यान्वयन है, डिफ़ॉल्ट रूप से यह लेख सेफ़ के बारे में बात करेगा, जब तक कि स्पष्ट रूप से अन्यथा न कहा गया हो). निर्दिष्ट मापदंडों के अनुसार, ऑपरेटर कॉन्फ़िगरेशन के लिए आवश्यक कमांड को स्वचालित रूप से निष्पादित करेगा।

आइए ऑब्जेक्ट स्टोर बनाने के उदाहरण का उपयोग करके विशिष्टताओं को देखें, या यों कहें - CephObjectStoreUser.

apiVersion: ceph.rook.io/v1
kind: CephObjectStore
metadata:
  name: {{ .Values.s3.crdName }}
  namespace: kube-rook
spec:
  metadataPool:
    failureDomain: host
    replicated:
      size: 3
  dataPool:
    failureDomain: host
    erasureCoded:
      dataChunks: 2
      codingChunks: 1
  gateway:
    type: s3
    sslCertificateRef:
    port: 80
    securePort:
    instances: 1
    allNodes: false
---
apiVersion: ceph.rook.io/v1
kind: CephObjectStoreUser
metadata:
  name: {{ .Values.s3.crdName }}
  namespace: kube-rook
spec:
  store: {{ .Values.s3.crdName }}
  displayName: {{ .Values.s3.username }}

सूची में दर्शाए गए पैरामीटर काफी मानक हैं और शायद ही टिप्पणियों की आवश्यकता है, लेकिन टेम्पलेट चर के लिए आवंटित मापदंडों पर विशेष ध्यान देना उचित है।

काम की सामान्य योजना इस तथ्य पर आधारित है कि हम एक YAML फ़ाइल के माध्यम से संसाधनों को "ऑर्डर" करते हैं, जिसके लिए ऑपरेटर आवश्यक आदेशों को निष्पादित करता है और हमें एक "असली" रहस्य लौटाता है जिसके साथ हम आगे काम कर सकते हैं (निचे देखो). और ऊपर सूचीबद्ध वेरिएबल्स से, कमांड और गुप्त नाम संकलित किया जाएगा।

यह किस प्रकार की टीम है? ऑब्जेक्ट स्टोरेज के लिए उपयोगकर्ता बनाते समय, पॉड के अंदर रूक ऑपरेटर निम्नलिखित कार्य करेगा:

radosgw-admin user create --uid="rook-user" --display-name="{{ .Values.s3.username }}"

इस आदेश को निष्पादित करने का परिणाम एक JSON संरचना होगा:

{
    "user_id": "rook-user",
    "display_name": "{{ .Values.s3.username }}",
    "keys": [
        {
           "user": "rook-user",
           "access_key": "NRWGT19TWMYOB1YDBV1Y",
           "secret_key": "gr1VEGIV7rxcP3xvXDFCo4UDwwl2YoNrmtRlIAty"
        }
    ],
    ...
}

Keys - भविष्य में किन अनुप्रयोगों को S3 API के माध्यम से ऑब्जेक्ट स्टोरेज तक पहुंचने की आवश्यकता होगी। रूक ऑपरेटर कृपया उनका चयन करता है और उन्हें नाम के साथ एक रहस्य के रूप में अपने नेमस्पेस में रखता है rook-ceph-object-user-{{ $.Values.s3.crdName }}-{{ $.Values.s3.username }}.

इस रहस्य से डेटा का उपयोग करने के लिए, बस इसे कंटेनर में पर्यावरण चर के रूप में जोड़ें। उदाहरण के तौर पर, मैं जॉब के लिए एक टेम्प्लेट दूंगा, जिसमें हम स्वचालित रूप से प्रत्येक उपयोगकर्ता परिवेश के लिए बकेट बनाते हैं:

{{- range $bucket := $.Values.s3.bucketNames }}
apiVersion: batch/v1
kind: Job
metadata:
  name: create-{{ $bucket }}-bucket-job
  annotations:
    "helm.sh/hook": post-install
    "helm.sh/hook-weight": "2"
spec:
  template:
    metadata:
      name: create-{{ $bucket }}-bucket-job
    spec:
      restartPolicy: Never
      initContainers:
      - name: waitdns
        image: alpine:3.6
        command: ["/bin/sh", "-c", "while ! getent ahostsv4 rook-ceph-rgw-{{ $.Values.s3.crdName }}; do sleep 1; done" ]
      - name: config
        image: rook/ceph:v1.0.0
        command: ["/bin/sh", "-c"]
        args: ["s3cmd --configure --access_key=$(ACCESS-KEY) --secret_key=$(SECRET-KEY) -s --no-ssl --dump-config | tee /config/.s3cfg"]
        volumeMounts:
        - name: config
          mountPath: /config
        env:
        - name: ACCESS-KEY
          valueFrom:
            secretKeyRef:
              name: rook-ceph-object-user-{{ $.Values.s3.crdName }}-{{ $.Values.s3.username }}
              key: AccessKey
        - name: SECRET-KEY
          valueFrom:
            secretKeyRef:
              name: rook-ceph-object-user-{{ $.Values.s3.crdName }}-{{ $.Values.s3.username }}
              key: SecretKey
      containers:
      - name: create-bucket
        image: rook/ceph:v1.0.0
        command: 
        - "s3cmd"
        - "mb"
        - "--host=rook-ceph-rgw-{{ $.Values.s3.crdName }}"
        - "--host-bucket= "
        - "s3://{{ $bucket }}"
        ports:
        - name: s3-no-sll
          containerPort: 80
        volumeMounts:
        - name: config
          mountPath: /root
      volumes:
      - name: config
        emptyDir: {}
---
{{- end }}

इस कार्य में सूचीबद्ध सभी कार्य कुबेरनेट्स के ढांचे के भीतर किए गए थे। YAML फ़ाइलों में वर्णित संरचनाएँ Git रिपॉजिटरी में संग्रहीत की जाती हैं और कई बार पुन: उपयोग की जाती हैं। हम इसे DevOps इंजीनियरों और समग्र रूप से CI/CD प्रक्रिया के लिए एक बड़े लाभ के रूप में देखते हैं।

रूक और राडोस से खुश

सेफ + आरबीडी संयोजन का उपयोग पॉड्स पर बढ़ते वॉल्यूम पर कुछ प्रतिबंध लगाता है।

विशेष रूप से, स्टेटफुल एप्लिकेशन के कार्य करने के लिए नेमस्पेस में सेफ तक पहुंचने के लिए एक रहस्य होना चाहिए। यह ठीक है यदि आपके पास उनके नामस्थान में 2-3 वातावरण हैं: आप जा सकते हैं और रहस्य को मैन्युअल रूप से कॉपी कर सकते हैं। लेकिन क्या होगा यदि प्रत्येक सुविधा के लिए डेवलपर्स के लिए अपने स्वयं के नामस्थान के साथ एक अलग वातावरण बनाया जाए?

हमने स्वयं इसका उपयोग करके इस समस्या का समाधान किया शेल-ऑपरेटर, जो स्वचालित रूप से रहस्यों को नए नामस्थानों में कॉपी करता है (ऐसे हुक का एक उदाहरण वर्णित है यह लेख).

#! /bin/bash

if [[ $1 == “--config” ]]; then
   cat <<EOF
{"onKubernetesEvent":[
 {"name": "OnNewNamespace",
  "kind": "namespace",
  "event": ["add"]
  }
]}
EOF
else
    NAMESPACE=$(kubectl get namespace -o json | jq '.items | max_by( .metadata.creationTimestamp ) | .metadata.name')
    kubectl -n ${CEPH_SECRET_NAMESPACE} get secret ${CEPH_SECRET_NAME} -o json | jq ".metadata.namespace="${NAMESPACE}"" | kubectl apply -f -
fi

हालाँकि, रूक का उपयोग करते समय यह समस्या मौजूद ही नहीं है। माउंटिंग प्रक्रिया अपने स्वयं के ड्राइवरों के आधार पर होती है फ्लेक्सवॉल्यूम या सीएसआई (अभी भी बीटा चरण में) और इसलिए रहस्यों की आवश्यकता नहीं है।

रूक स्वचालित रूप से कई समस्याओं का समाधान करता है, जो हमें नई परियोजनाओं में इसका उपयोग करने के लिए प्रोत्साहित करता है।

रूक की घेराबंदी

आइए रूक और सेफ को तैनात करके व्यावहारिक भाग को पूरा करें ताकि हम अपने स्वयं के प्रयोग कर सकें। इस अभेद्य टावर पर धावा बोलना आसान बनाने के लिए डेवलपर्स ने एक हेल्म पैकेज तैयार किया है। आइए इसे डाउनलोड करें:

$ helm fetch rook-master/rook-ceph --untar --version 1.0.0

फाइल मैं rook-ceph/values.yaml आप कई अलग-अलग सेटिंग्स पा सकते हैं। सबसे महत्वपूर्ण बात एजेंटों और खोज के लिए सहनशीलता निर्दिष्ट करना है। हमने विस्तार से वर्णन किया है कि कलंक/सहनशीलता तंत्र का उपयोग किस लिए किया जा सकता है यह लेख.

संक्षेप में, हम नहीं चाहते कि क्लाइंट एप्लिकेशन पॉड्स डेटा स्टोरेज डिस्क के समान नोड्स पर स्थित हों। कारण सरल है: इस तरह रूक एजेंटों का काम एप्लिकेशन को प्रभावित नहीं करेगा।

तो, फ़ाइल खोलें rook-ceph/values.yaml अपने पसंदीदा संपादक के साथ और अंत में निम्नलिखित ब्लॉक जोड़ें:

discover:
  toleration: NoExecute
  tolerationKey: node-role/storage
agent:
  toleration: NoExecute
  tolerationKey: node-role/storage
  mountSecurityMode: Any

डेटा भंडारण के लिए आरक्षित प्रत्येक नोड के लिए, संबंधित टेंट जोड़ें:

$ kubectl taint node ${NODE_NAME} node-role/storage="":NoExecute

फिर कमांड के साथ हेल्म चार्ट स्थापित करें:

$ helm install --namespace ${ROOK_NAMESPACE} ./rook-ceph

अब आपको एक क्लस्टर बनाना होगा और स्थान निर्दिष्ट करना होगा ओएसडी:

apiVersion: ceph.rook.io/v1
kind: CephCluster
metadata:
  clusterName: "ceph"
  finalizers:
  - cephcluster.ceph.rook.io
  generation: 1
  name: rook-ceph
spec:
  cephVersion:
    image: ceph/ceph:v13
  dashboard:
    enabled: true
  dataDirHostPath: /var/lib/rook/osd
  mon:
    allowMultiplePerNode: false
    count: 3
  network:
    hostNetwork: true
  rbdMirroring:
    workers: 1
  placement:
    all:
      tolerations:
      - key: node-role/storage
        operator: Exists
  storage:
    useAllNodes: false
    useAllDevices: false
    config:
      osdsPerDevice: "1"
      storeType: filestore
    resources:
      limits:
        memory: "1024Mi"
      requests:
        memory: "1024Mi"
    nodes:
    - name: host-1
      directories:
      - path: "/mnt/osd"
    - name: host-2
      directories:
      - path: "/mnt/osd"
    - name: host-3
      directories:
      - path: "/mnt/osd"

सेफ स्थिति की जाँच - देखने की उम्मीद है HEALTH_OK:

$ kubectl -n ${ROOK_NAMESPACE} exec $(kubectl -n ${ROOK_NAMESPACE} get pod -l app=rook-ceph-operator -o name -o jsonpath='{.items[0].metadata.name}') -- ceph -s

उसी समय, आइए जाँच करें कि क्लाइंट एप्लिकेशन वाले पॉड्स सेफ के लिए आरक्षित नोड्स पर समाप्त न हों:

$ kubectl -n ${APPLICATION_NAMESPACE} get pods -o custom-columns=NAME:.metadata.name,NODE:.spec.nodeName

इसके अलावा, अतिरिक्त घटकों को इच्छानुसार कॉन्फ़िगर किया जा सकता है। उनके बारे में अधिक जानकारी दी गई है प्रलेखन. प्रशासन के लिए, हम दृढ़ता से डैशबोर्ड और टूलबॉक्स स्थापित करने की अनुशंसा करते हैं।

रूक और हुक: क्या रूक हर चीज के लिए पर्याप्त है?

जैसा कि आप देख सकते हैं, रूक का विकास जोरों पर है। लेकिन अभी भी ऐसी समस्याएं हैं जो हमें सेफ के मैन्युअल कॉन्फ़िगरेशन को पूरी तरह से त्यागने की अनुमति नहीं देती हैं:

• कोई रूक ड्राइवर नहीं नही सकता माउंटेड ब्लॉकों के उपयोग पर निर्यात मेट्रिक्स, जो हमें निगरानी से वंचित करता है।
• फ्लेक्सवॉल्यूम और सीएसआई पता नहीं कैसे वॉल्यूम का आकार बदलें (उसी आरबीडी के विपरीत), इसलिए रूक एक उपयोगी (और कभी-कभी गंभीर रूप से आवश्यक!) टूल से वंचित है।
• रूक अभी भी नियमित सेफ जितना लचीला नहीं है। यदि हम SSD पर संग्रहीत CephFS मेटाडेटा के लिए पूल को कॉन्फ़िगर करना चाहते हैं, और डेटा को HDD पर संग्रहीत करना चाहते हैं, तो हमें CRUSH मानचित्रों में उपकरणों के अलग-अलग समूहों को मैन्युअल रूप से पंजीकृत करने की आवश्यकता होगी।
• इस तथ्य के बावजूद कि rook-ceph-ऑपरेटर को स्थिर माना जाता है, वर्तमान में Ceph को संस्करण 13 से 14 में अपग्रेड करते समय कुछ समस्याएं हैं।

निष्कर्ष

"अभी प्यादों द्वारा रूक को बाहरी दुनिया से दूर रखा गया है, लेकिन हमें विश्वास है कि एक दिन वह खेल में निर्णायक भूमिका निभाएगी!" (इस लेख के लिए विशेष रूप से आविष्कार किया गया उद्धरण)

रूक परियोजना ने निस्संदेह हमारा दिल जीत लिया है - हमारा मानना ​​है कि [इसके सभी फायदे और नुकसान के साथ] यह निश्चित रूप से आपका ध्यान आकर्षित करने योग्य है।

हमारी भविष्य की योजनाएँ rook-ceph को एक मॉड्यूल बनाने तक सीमित हैं addon-ऑपरेटर, जो हमारे असंख्य कुबेरनेट समूहों में इसके उपयोग को और भी सरल और अधिक सुविधाजनक बना देगा।

पुनश्च

हमारे ब्लॉग पर भी पढ़ें:

• «रूक - कुबेरनेट्स के लिए "स्वयं-सेवा" डेटा वेयरहाउस";
• «सेफ़ पर आधारित कुबेरनेट्स में प्रावधान के साथ सतत भंडारण बनाना";
• «डेटाबेस और कुबेरनेट्स (समीक्षा और वीडियो रिपोर्ट)";
• «शेल-ऑपरेटर का परिचय: कुबेरनेट्स के लिए ऑपरेटर बनाना अब आसान हो गया है";
• «कुबेरनेट्स के लिए ऑपरेटर: स्टेटफुल एप्लिकेशन कैसे चलाएं'.

स्रोत: www.habr.com