રુક માટે કે રુક માટે નહીં - તે પ્રશ્ન છે

આ મહિનાની શરૂઆતમાં, 3 મેના રોજ, "કુબરનેટ્સમાં વિતરિત ડેટા સ્ટોરેજ માટે મેનેજમેન્ટ સિસ્ટમ" ની મુખ્ય રજૂઆતની જાહેરાત કરવામાં આવી હતી - રૂક 1.0.0. એક વર્ષ કરતાં વધુ પહેલાં અમે પહેલેથી જ પ્રકાશિત રૂકની સામાન્ય ઝાંખી. પછી અમને તેમના અનુભવ વિશે વાત કરવાનું કહેવામાં આવ્યું વ્યવહારમાં ઉપયોગ કરો — અને હવે, પ્રોજેક્ટના ઇતિહાસમાં આવા નોંધપાત્ર સીમાચિહ્નરૂપ સમય માટે, અમે અમારી સંચિત છાપ શેર કરવામાં ખુશ છીએ.

ટૂંકમાં, રુક એક સમૂહ છે ઓપરેટરો કુબરનેટ્સ માટે, જે ડેટા સ્ટોરેજ સોલ્યુશન્સ જેમ કે Ceph, EdgeFS, Minio, Cassandra, CockroachDB ના જમાવટ, સંચાલન, સ્વચાલિત પુનઃપ્રાપ્તિનું સંપૂર્ણ નિયંત્રણ લે છે.

આ ક્ષણે સૌથી વધુ વિકસિત (અને માત્ર એક જ в સ્થિર સ્ટેજ) ઉકેલ છે rook-ceph-operator.

નોંધણી: Ceph સંબંધિત રુક 1.0.0 રિલીઝમાં નોંધપાત્ર ફેરફારો પૈકી, અમે Ceph Nautilus માટે સમર્થન અને CephFS અથવા RGW બકેટ્સ માટે NFS નો ઉપયોગ કરવાની ક્ષમતાને નોંધી શકીએ છીએ. બીટા સ્તર પર એજએફએસ સપોર્ટની પરિપક્વતા એ અન્ય લોકોમાં અલગ છે.

તેથી, આ લેખમાં આપણે:

• કુબરનેટ્સ ક્લસ્ટરમાં સેફને જમાવવા માટે રુકનો ઉપયોગ કરવાથી આપણને કયા ફાયદા દેખાય છે તે અંગેના પ્રશ્નનો જવાબ આપીએ;
• અમે ઉત્પાદનમાં રુકનો ઉપયોગ કરવાના અમારા અનુભવ અને છાપને શેર કરીશું;
• ચાલો તમને કહીએ કે શા માટે અમે રુકને “હા!” કહીએ છીએ અને તેના માટે અમારી યોજનાઓ વિશે.

ચાલો સામાન્ય ખ્યાલો અને સિદ્ધાંત સાથે પ્રારંભ કરીએ.

"મને એક રુકનો ફાયદો છે!" (અજાણ્યા ચેસ ખેલાડી)

રુકના મુખ્ય ફાયદાઓમાંનો એક એ છે કે ડેટા સ્ટોર્સ સાથેની ક્રિયાપ્રતિક્રિયા કુબરનેટ્સ મિકેનિઝમ્સ દ્વારા હાથ ધરવામાં આવે છે. આનો અર્થ એ છે કે તમારે હવે કન્સોલમાં શીટમાંથી Ceph ને ગોઠવવા માટે આદેશોની નકલ કરવાની જરૂર નથી.

— શું તમે ક્લસ્ટરમાં CephFS જમાવવા માંગો છો? ફક્ત YAML ફાઇલ લખો!
- શું? શું તમે S3 API સાથે ઑબ્જેક્ટ સ્ટોર પણ જમાવવા માંગો છો? ફક્ત બીજી YAML ફાઇલ લખો!

રુક સામાન્ય ઓપરેટરના તમામ નિયમો અનુસાર બનાવવામાં આવે છે. તેનો ઉપયોગ કરીને તેની સાથે ક્રિયાપ્રતિક્રિયા થાય છે CRD (કસ્ટમ રિસોર્સ ડેફિનેશન), જેમાં આપણે જરૂરી Ceph એન્ટિટીની લાક્ષણિકતાઓનું વર્ણન કરીએ છીએ (કારણ કે આ એકમાત્ર સ્થિર અમલીકરણ છે, મૂળભૂત રીતે આ લેખ Ceph વિશે વાત કરશે, સિવાય કે સ્પષ્ટપણે અન્યથા જણાવવામાં આવે). ઉલ્લેખિત પરિમાણો અનુસાર, ઓપરેટર રૂપરેખાંકન માટે જરૂરી આદેશોને આપમેળે એક્ઝિક્યુટ કરશે.

ચાલો ઑબ્જેક્ટ સ્ટોર બનાવવાના ઉદાહરણનો ઉપયોગ કરીને સ્પષ્ટીકરણો જોઈએ, અથવા તેના બદલે - 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 ફાઇલોમાં વર્ણવેલ સ્ટ્રક્ચર્સ ગિટ રિપોઝીટરીમાં સંગ્રહિત થાય છે અને ઘણી વખત પુનઃઉપયોગ કરવામાં આવે છે. અમે આને DevOps એન્જિનિયરો અને સમગ્ર રીતે CI/CD પ્રક્રિયા માટે એક વિશાળ વત્તા તરીકે જોઈએ છીએ.

રુક અને રાડોસથી ખુશ

Ceph + RBD કોમ્બિનેશનનો ઉપયોગ પોડ્સ પર વોલ્યુમને માઉન્ટ કરવા પર ચોક્કસ નિયંત્રણો લાદે છે.

ખાસ કરીને, સ્ટેટફુલ એપ્લીકેશન કાર્ય કરવા માટે નેમસ્પેસમાં Ceph ને ઍક્સેસ કરવા માટે એક રહસ્ય હોવું આવશ્યક છે. જો તમારી પાસે તેમની નેમસ્પેસમાં 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

જો કે, રુકનો ઉપયોગ કરતી વખતે આ સમસ્યા અસ્તિત્વમાં નથી. માઉન્ટિંગ પ્રક્રિયા તેના આધારે તેના પોતાના ડ્રાઇવરોનો ઉપયોગ કરીને થાય છે ફ્લેક્સવોલ્યુમ અથવા CSI (હજુ બીટા તબક્કામાં છે) અને તેથી રહસ્યોની જરૂર નથી.

રુક આપમેળે ઘણી સમસ્યાઓ હલ કરે છે, જે અમને નવા પ્રોજેક્ટ્સમાં તેનો ઉપયોગ કરવા પ્રોત્સાહિત કરે છે.

રુકનો ઘેરો

ચાલો રુક અને સેફનો ઉપયોગ કરીને વ્યવહારુ ભાગ પૂર્ણ કરીએ જેથી કરીને આપણે આપણા પોતાના પ્રયોગો કરી શકીએ. આ અભેદ્ય ટાવર પર તોફાન કરવાનું સરળ બનાવવા માટે, વિકાસકર્તાઓએ હેલ્મ પેકેજ તૈયાર કર્યું છે. ચાલો તેને ડાઉનલોડ કરીએ:

$ 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"

Ceph સ્થિતિ તપાસી રહ્યું છે - જોવાની અપેક્ષા 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

તે જ સમયે, ચાલો તપાસ કરીએ કે ક્લાયંટ એપ્લિકેશન સાથેના પોડ્સ Ceph માટે આરક્ષિત નોડ્સ પર સમાપ્ત થતા નથી:

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

વધુમાં, વધારાના ઘટકોને ઈચ્છા પ્રમાણે ગોઠવી શકાય છે. તેમના વિશે વધુ વિગતો આમાં સૂચવવામાં આવી છે દસ્તાવેજીકરણ. વહીવટ માટે, અમે ડેશબોર્ડ અને ટૂલબોક્સ ઇન્સ્ટોલ કરવાની ભારપૂર્વક ભલામણ કરીએ છીએ.

રુક અને હુક્સ: શું રુક દરેક વસ્તુ માટે પૂરતું છે?

જેમ તમે જોઈ શકો છો, રુકનો વિકાસ પૂરજોશમાં છે. પરંતુ હજી પણ એવી સમસ્યાઓ છે જે અમને સેફના મેન્યુઅલ ગોઠવણીને સંપૂર્ણપણે છોડી દેવાની મંજૂરી આપતી નથી:

• કોઈ રુક ડ્રાઈવર નથી કરી શકતા નથી માઉન્ટેડ બ્લોક્સના ઉપયોગ પર નિકાસ મેટ્રિક્સ, જે અમને દેખરેખથી વંચિત રાખે છે.
• ફ્લેક્સવોલ્યુમ અને CSI કેવી રીતે ખબર નથી વોલ્યુમનું કદ બદલો (સમાન આરબીડીની વિરુદ્ધ), તેથી રુક ઉપયોગી (અને ક્યારેક વિવેચનાત્મક રીતે જરૂરી!) સાધનથી વંચિત રહે છે.
• રુક હજુ પણ નિયમિત કેફની જેમ લવચીક નથી. જો આપણે સેફએફએસ મેટાડેટાને SSD પર સંગ્રહિત કરવા માટે પૂલને ગોઠવવા માંગીએ છીએ, અને ડેટા પોતે HDD પર સંગ્રહિત થાય છે, તો અમારે CRUSH નકશામાં મેન્યુઅલી ઉપકરણોના અલગ જૂથોની નોંધણી કરવાની જરૂર પડશે.
• રુક-સેફ-ઓપરેટરને સ્થિર માનવામાં આવે છે તે હકીકત હોવા છતાં, હાલમાં સંસ્કરણ 13 થી 14 સુધી Ceph ને અપગ્રેડ કરતી વખતે કેટલીક સમસ્યાઓ છે.

તારણો

"અત્યારે રુક બહારની દુનિયાથી પ્યાદાઓ દ્વારા બંધ છે, પરંતુ અમે માનીએ છીએ કે એક દિવસ તે રમતમાં નિર્ણાયક ભૂમિકા ભજવશે!" (આ લેખ માટે ખાસ શોધાયેલ અવતરણ)

રુક પ્રોજેક્ટે નિઃશંકપણે અમારું હૃદય જીતી લીધું છે - અમે માનીએ છીએ કે [તેના તમામ ગુણદોષ સાથે] તે ચોક્કસપણે તમારા ધ્યાનને પાત્ર છે.

અમારી ભાવિ યોજનાઓ રૂક-સેફ માટે મોડ્યુલ બનાવવા માટે ઉકળે છે એડઓન ઓપરેટર, જે અમારા અસંખ્ય કુબરનેટ્સ ક્લસ્ટરોમાં તેનો ઉપયોગ વધુ સરળ અને વધુ અનુકૂળ બનાવશે.

PS

અમારા બ્લોગ પર પણ વાંચો:

• «રુક - કુબરનેટ્સ માટે "સ્વ-સેવા" ડેટા વેરહાઉસ»;
• «Ceph પર આધારિત કુબરનેટ્સમાં જોગવાઈ સાથે સતત સ્ટોરેજ બનાવવું»;
• «ડેટાબેસેસ અને કુબરનેટ્સ (સમીક્ષા અને વિડિયો રિપોર્ટ)»;
• «શેલ-ઓપરેટરનો પરિચય: કુબરનેટ્સ માટે ઓપરેટર બનાવવાનું સરળ બન્યું છે»;
• «કુબરનેટ્સ માટે ઓપરેટર્સ: સ્ટેટફુલ એપ્લિકેશન કેવી રીતે ચલાવવી».

સોર્સ: www.habr.com