សៀវភៅ “Kubernetes for DevOps”

ជំរាបសួរអ្នកស្រុក Khabro! Kubernetes គឺជាធាតុសំខាន់មួយនៃប្រព័ន្ធអេកូឡូស៊ីពពកទំនើប។ បច្ចេកវិទ្យានេះផ្តល់នូវភាពជឿជាក់ ការធ្វើមាត្រដ្ឋាន និងភាពធន់ទៅនឹងនិម្មិតកុងតឺន័រ។ John Arundel និង Justin Domingus និយាយអំពីប្រព័ន្ធអេកូ Kubernetes និងណែនាំដំណោះស្រាយដែលបង្ហាញឱ្យឃើញចំពោះបញ្ហាប្រចាំថ្ងៃ។ មួយជំហានម្តងៗ អ្នកនឹងបង្កើតកម្មវិធី cloud-native ផ្ទាល់ខ្លួនរបស់អ្នក និងបង្កើតហេដ្ឋារចនាសម្ព័ន្ធដើម្បីគាំទ្រវា រៀបចំបរិយាកាសអភិវឌ្ឍន៍ និងបំពង់ចែកចាយបន្តដែលនឹងជួយអ្នកនៅពេលអ្នកធ្វើការលើកម្មវិធីបន្ទាប់របស់អ្នក។

• ចាប់ផ្តើមជាមួយកុងតឺន័រ និង Kubernetes ពីមូលដ្ឋានគ្រឹះ៖ មិនចាំបាច់មានបទពិសោធន៍ពិសេសដើម្បីរៀនប្រធានបទនោះទេ។ • ដំណើរការក្រុមផ្ទាល់ខ្លួនរបស់អ្នក ឬជ្រើសរើសសេវាកម្ម Kubernetes ដែលបានគ្រប់គ្រងពី Amazon, Google ។ល។ • ប្រើ Kubernetes ដើម្បីគ្រប់គ្រងវដ្តជីវិតកុងតឺន័រ និងការប្រើប្រាស់ធនធាន។ • បង្កើនប្រសិទ្ធភាពក្រុមដោយផ្អែកលើការចំណាយ ការអនុវត្ត ភាពធន់ ថាមពល និងលទ្ធភាពធ្វើមាត្រដ្ឋាន។ • ស្វែងយល់ពីឧបករណ៍ល្អបំផុតដើម្បីអភិវឌ្ឍ សាកល្បង និងដាក់ឱ្យប្រើប្រាស់កម្មវិធីរបស់អ្នក។ • ប្រើប្រាស់ការអនុវត្តឧស្សាហកម្មបច្ចុប្បន្ន ដើម្បីធានាសុវត្ថិភាព និងការគ្រប់គ្រង។ • អនុវត្តគោលការណ៍ DevOps នៅទូទាំងក្រុមហ៊ុនរបស់អ្នក ដើម្បីឱ្យក្រុមអភិវឌ្ឍន៍អាចធ្វើសកម្មភាពកាន់តែមានភាពបត់បែន រហ័ស និងមានប្រសិទ្ធភាព។

តើសៀវភៅសម្រាប់អ្នកណា?

សៀវភៅនេះគឺពាក់ព័ន្ធបំផុតសម្រាប់បុគ្គលិកនៃនាយកដ្ឋានរដ្ឋបាលដែលទទួលខុសត្រូវលើម៉ាស៊ីនមេ កម្មវិធី និងសេវាកម្ម ក៏ដូចជាសម្រាប់អ្នកអភិវឌ្ឍន៍ដែលពាក់ព័ន្ធនឹងការកសាងសេវាកម្មពពកថ្មី ឬផ្ទេរកម្មវិធីដែលមានស្រាប់ទៅ Kubernetes និងពពក។ កុំបារម្ភ អ្នកមិនចាំបាច់ដឹងពីរបៀបធ្វើការជាមួយ Kubernetes ឬកុងតឺន័រទេ យើងនឹងបង្រៀនអ្នកគ្រប់យ៉ាង។

អ្នកប្រើប្រាស់ Kubernetes ដែលមានបទពិសោធន៍ក៏នឹងរកឃើញតម្លៃជាច្រើនផងដែរ ជាមួយនឹងការគ្របដណ្តប់ស៊ីជម្រៅនៃប្រធានបទដូចជា RBAC ការដាក់ឱ្យប្រើប្រាស់ជាបន្ត ការគ្រប់គ្រងទិន្នន័យរសើប និងការសង្កេត។ យើងសង្ឃឹមថាទំព័រនៃសៀវភៅនេះពិតជាមានអ្វីដែលគួរឱ្យចាប់អារម្មណ៍សម្រាប់អ្នក ដោយមិនគិតពីជំនាញ និងបទពិសោធន៍របស់អ្នក។

តើសៀវភៅឆ្លើយសំណួរអ្វីខ្លះ?

ខណៈពេលដែលកំពុងរៀបចំផែនការ និងសរសេរសៀវភៅនេះ យើងបានពិភាក្សាអំពីបច្ចេកវិទ្យាពពក និង Kubernetes ជាមួយមនុស្សរាប់រយនាក់ ដោយនិយាយជាមួយអ្នកដឹកនាំឧស្សាហកម្ម និងអ្នកជំនាញ ព្រមទាំងអ្នកថ្មីថ្មោងពេញលេញផងដែរ។ ខាងក្រោម​នេះ​គឺ​ជា​សំណួរ​ដែល​ពួកគេ​ចង់​ឃើញ​មាន​ចម្លើយ​នៅ​ក្នុង​ការ​បោះផ្សាយ​នេះ។

• “ខ្ញុំចាប់អារម្មណ៍ថាហេតុអ្វីបានជាអ្នកគួរចំណាយពេលលើបច្ចេកវិទ្យានេះ។ តើ​បញ្ហា​អ្វី​ខ្លះ​ដែល​វា​នឹង​ជួយ​ខ្ញុំ និង​ក្រុម​របស់​ខ្ញុំ​ដោះស្រាយ?”
• “Kubernetes ហាក់ដូចជាគួរឱ្យចាប់អារម្មណ៍ ប៉ុន្តែមានឧបសគ្គខ្ពស់ក្នុងការចូល។ ការ​រៀបចំ​ឧទាហរណ៍​សាមញ្ញ​មួយ​មិន​ពិបាក​ទេ ប៉ុន្តែ​ការ​គ្រប់គ្រង​និង​ការ​បំបាត់​កំហុស​បន្ថែម​ទៀត​គឺ​ជា​រឿង​គួរ​ឱ្យ​ខ្លាច។ យើងចង់ទទួលបានដំបូន្មានដែលអាចទុកចិត្តបានអំពីរបៀបដែលមនុស្សគ្រប់គ្រងក្រុម Kubernetes នៅក្នុងពិភពពិត និងបញ្ហាអ្វីដែលយើងទំនងជាជួបប្រទះ។
• “ដំបូន្មានតាមប្រធានបទនឹងមានប្រយោជន៍។ ប្រព័ន្ធ​អេកូឡូស៊ី Kubernetes ផ្តល់​ឱ្យ​ក្រុម​ថ្មី​ជម្រើស​ច្រើន​ពេក​ក្នុង​ការ​ជ្រើសរើស។ នៅពេលដែលមានវិធីជាច្រើនដើម្បីធ្វើរឿងដូចគ្នា តើអ្នកដឹងដោយរបៀបណាថាមួយណាល្អជាងគេ? តើ​ធ្វើ​ដូចម្តេច​ដើម្បី​ធ្វើ​ឱ្យ​មាន​ជម្រើស​មួយ​?

ហើយប្រហែលជាសំខាន់បំផុតនៃសំណួរទាំងអស់៖

• "តើខ្ញុំអាចប្រើ Kubernetes ដោយមិនរំខានក្រុមហ៊ុនរបស់ខ្ញុំដោយរបៀបណា?"

ដកស្រង់។ ការកំណត់រចនាសម្ព័ន្ធ និងវត្ថុសម្ងាត់

សមត្ថភាពក្នុងការបំបែកតក្កវិជ្ជានៃកម្មវិធី Kubernetes ពីការកំណត់របស់វា (នោះគឺពីតម្លៃ ឬការកំណត់ដែលអាចផ្លាស់ប្តូរតាមពេលវេលា) គឺមានប្រយោជន៍ណាស់។ តម្លៃកំណត់រចនាសម្ព័ន្ធជាធម្មតារួមបញ្ចូលការកំណត់ជាក់លាក់នៃបរិស្ថាន អាសយដ្ឋាន DNS សេវាកម្មភាគីទីបី និងព័ត៌មានបញ្ជាក់ការផ្ទៀងផ្ទាត់។

ជាការពិតណាស់ទាំងអស់នេះអាចត្រូវបានដាក់ដោយផ្ទាល់ទៅក្នុងកូដប៉ុន្តែវិធីសាស្រ្តនេះមិនមានភាពបត់បែនគ្រប់គ្រាន់ទេ។ ឧទាហរណ៍ ការផ្លាស់ប្តូរតម្លៃកំណត់រចនាសម្ព័ន្ធនឹងតម្រូវឱ្យអ្នកបង្កើត និងដាក់ឱ្យប្រើប្រាស់កូដរបស់អ្នកម្តងទៀត។ ដំណោះស្រាយប្រសើរជាងមុនគឺត្រូវបំបែកការកំណត់រចនាសម្ព័ន្ធចេញពីកូដ ហើយអានវាពីឯកសារ ឬអថេរបរិស្ថាន។

Kubernetes ផ្តល់នូវវិធីផ្សេងគ្នាជាច្រើនដើម្បីគ្រប់គ្រងការកំណត់រចនាសម្ព័ន្ធ។ ដំបូង អ្នក​អាច​បញ្ជូន​តម្លៃ​ទៅ​កម្មវិធី​តាម​រយៈ​អថេរ​បរិស្ថាន​ដែល​បាន​បញ្ជាក់​ក្នុង​ការ​បញ្ជាក់​ក្នុង​ការ​បញ្ជាក់​នៃ​កញ្ចប់​ក្រដាស (សូម​មើល "អថេរ​បរិស្ថាន" នៅ​ទំព័រ 192)។ ទីពីរ ទិន្នន័យកំណត់រចនាសម្ព័ន្ធអាចត្រូវបានរក្សាទុកដោយផ្ទាល់នៅក្នុង Kubernetes ដោយប្រើ ConfigMap និងវត្ថុសម្ងាត់។

នៅក្នុងជំពូកនេះ យើងរុករកវត្ថុទាំងនេះឱ្យបានលម្អិត ហើយពិនិត្យមើលវិធីសាស្រ្តជាក់ស្តែងមួយចំនួនក្នុងការគ្រប់គ្រងការកំណត់រចនាសម្ព័ន្ធ និងទិន្នន័យរសើបដោយប្រើកម្មវិធីសាកល្បង។

កំពុងអាប់ដេតសំបកផត នៅពេលការកំណត់ផ្លាស់ប្តូរ

ស្រមៃថាអ្នកមានការដាក់ពង្រាយនៅក្នុងចង្កោមរបស់អ្នក ហើយអ្នកចង់ផ្លាស់ប្តូរតម្លៃមួយចំនួននៅក្នុង ConfigMap របស់វា។ ប្រសិនបើអ្នកប្រើគំនូសតាង Helm (សូមមើល “Helm: Package Manager for Kubernetes” នៅទំព័រ 102) អ្នកអាចរកឃើញការផ្លាស់ប្តូរការកំណត់រចនាសម្ព័ន្ធដោយស្វ័យប្រវត្តិ ហើយផ្ទុកសំបក pod របស់អ្នកឡើងវិញក្នុងល្បិចដ៏ស្អាតមួយ។ បន្ថែមចំណារពន្យល់ខាងក្រោមទៅនឹងការកំណត់នៃការដាក់ពង្រាយរបស់អ្នក៖

checksum/config: {{ include (print $.Template.BasePath "/configmap.yaml") .
       | sha256sum }}

គំរូនៃការដាក់ពង្រាយឥឡូវនេះមាន checksum នៃប៉ារ៉ាម៉ែត្រកំណត់រចនាសម្ព័ន្ធ៖ ប្រសិនបើប៉ារ៉ាម៉ែត្រត្រូវបានផ្លាស់ប្តូរ ផលបូកនឹងត្រូវបានធ្វើបច្ចុប្បន្នភាព។ ប្រសិនបើអ្នកដំណើរការការអាប់ដេតមួកសុវត្ថិភាព Helm នឹងរកឃើញថាការកំណត់នៃការដាក់ពង្រាយបានផ្លាស់ប្តូរ ហើយនឹងចាប់ផ្តើមសែល pod ទាំងអស់ឡើងវិញ។

ទិន្នន័យរសើបនៅក្នុង Kubernetes

យើងដឹងរួចហើយថាវត្ថុ ConfigMap ផ្តល់នូវយន្តការដែលអាចបត់បែនបានសម្រាប់ការរក្សាទុក និងការចូលប្រើទិន្នន័យការកំណត់រចនាសម្ព័ន្ធនៅក្នុងចង្កោមមួយ។ ទោះយ៉ាងណាក៏ដោយ កម្មវិធីភាគច្រើនមានព័ត៌មានដែលមានលក្ខណៈរសើប និងរសើប ដូចជាពាក្យសម្ងាត់ ឬសោ API ជាដើម។ វាក៏អាចត្រូវបានរក្សាទុកនៅក្នុង ConfigMap ផងដែរ ប៉ុន្តែដំណោះស្រាយនេះមិនសមស្របទេ។

ជំនួសមកវិញ Kubernetes ផ្តល់ជូននូវប្រភេទពិសេសនៃវត្ថុដែលបានរចនាឡើងដើម្បីរក្សាទុកទិន្នន័យរសើប៖ សម្ងាត់។ បន្ទាប់មក សូមក្រឡេកមើលឧទាហរណ៍អំពីរបៀបដែលវត្ថុនេះអាចត្រូវបានប្រើនៅក្នុងកម្មវិធីសាកល្បងរបស់យើង។

ដើម្បីចាប់ផ្តើម សូមមើលការបង្ហាញ Kubernetes សម្រាប់វត្ថុសម្ងាត់ (សូមមើល hello-secret-env/k8s/secret.yaml)៖

apiVersion: v1
kind: Secret
metadata:
    name: demo-secret
stringData:
    magicWord: xyzzy

ក្នុងឧទាហរណ៍នេះ សោឯកជននៃពាក្យវេទមន្តគឺ xyzzy (en.wikipedia.org/wiki/Xyzzy_(computing))។ ពាក្យ xyzzy ជាទូទៅមានប្រយោជន៍ខ្លាំងណាស់នៅក្នុងពិភពកុំព្យូទ័រ។ ស្រដៀងទៅនឹង ConfigMap អ្នកអាចរក្សាទុកសោ និងតម្លៃជាច្រើននៅក្នុងវត្ថុសម្ងាត់មួយ។ នៅទីនេះ ដើម្បីភាពសាមញ្ញ យើងប្រើគូតម្លៃតម្លៃតែមួយប៉ុណ្ណោះ។

ការប្រើប្រាស់វត្ថុសម្ងាត់ជាអថេរបរិស្ថាន

ដូច ConfigMap វត្ថុសម្ងាត់អាចត្រូវបានធ្វើឱ្យមាននៅក្នុងកុងតឺន័រជាអថេរបរិស្ថាន ឬជាឯកសារនៅលើថាសរបស់វា។ ក្នុងឧទាហរណ៍ខាងក្រោម យើងនឹងកំណត់អថេរបរិស្ថានទៅតម្លៃពី Secret៖

spec:
   containers:
       - name: demo
          image: cloudnatived/demo:hello-secret-env
          ports:
             - containerPort: 8888
          env:
             - name: GREETING
               valueFrom:
               secretKeyRef:
                  name: demo-secret
                  key: magicWord

ដំណើរការពាក្យបញ្ជាខាងក្រោមនៅក្នុងឃ្លាំងសាកល្បង ដើម្បីអនុវត្ត manifests៖

kubectl apply -f hello-secret-env/k8s/
deployment.extensions "demo" configured
secret "demo-secret" created

ដូចពីមុន បញ្ជូនច្រកមូលដ្ឋានទៅកាន់ការដាក់ពង្រាយ ដើម្បីមើលលទ្ធផលនៅក្នុងកម្មវិធីរុករករបស់អ្នក៖

kubectl port-forward deploy/demo 9999:8888
Forwarding from 127.0.0.1:9999 -> 8888
Forwarding from [::1]:9999 -> 8888

នៅពេលបើកអាសយដ្ឋាន localhost:9999/ អ្នកគួរតែឃើញដូចខាងក្រោម៖

The magic word is "xyzzy"

ការសរសេរវត្ថុសម្ងាត់ទៅក្នុងឯកសារ

ក្នុងឧទាហរណ៍នេះ យើងនឹងភ្ជាប់វត្ថុសម្ងាត់ទៅកុងតឺន័រជាឯកសារ។ លេខកូដមានទីតាំងនៅក្នុងថតឯកសារ hello-secret-file នៃឃ្លាំងសាកល្បង។

ដើម្បីភ្ជាប់ Secret ជាឯកសារ យើងនឹងប្រើការដាក់ពង្រាយខាងក្រោម៖

spec:
   containers:
       - name: demo
          image: cloudnatived/demo:hello-secret-file
          ports:
              - containerPort: 8888
          volumeMounts:
              - name: demo-secret-volume
                mountPath: "/secrets/"
                readOnly: true
   volumes:
      - name: demo-secret-volume
        secret:
           secretName: demo-secret

ដូចនៅក្នុងផ្នែករង "ការបង្កើតឯកសារកំណត់រចនាសម្ព័ន្ធពីវត្ថុ ConfigMap" នៅលើទំ។ 240 យើងបង្កើតកម្រិតសំឡេង (ក្នុងករណីនេះ demo-secret-volume) ហើយភ្ជាប់វាទៅកុងតឺន័រក្នុងផ្នែក volumeMounts នៃការបញ្ជាក់។ វាល mountPath គឺ /secrets ដូច្នេះ Kubernetes នឹងបង្កើតឯកសារមួយនៅក្នុងថតនេះសម្រាប់គូ key/value នីមួយៗដែលបានកំណត់ក្នុង Secret object។

ក្នុងឧទាហរណ៍របស់យើង យើងបានកំណត់តែគូតម្លៃ key-value មួយប៉ុណ្ណោះដែលហៅថា magicWord ដូច្នេះ manifest នឹងបង្កើត file /secrets/magicWord ដែលអានបានតែមួយជាមួយទិន្នន័យរសើបនៅក្នុងកុងតឺន័រ។

ប្រសិនបើអ្នកអនុវត្ត manifest នេះតាមរបៀបដូចគ្នានឹងឧទាហរណ៍មុន អ្នកគួរតែទទួលបានលទ្ធផលដូចគ្នា៖

The magic word is "xyzzy"

ការអានវត្ថុសម្ងាត់

នៅក្នុងផ្នែកមុន យើងបានប្រើពាក្យបញ្ជា kubectl describe ដើម្បីបង្ហាញមាតិកានៃ ConfigMap ។ តើអាចធ្វើដូចគ្នាជាមួយ Secret បានទេ?

kubectl describe secret/demo-secret
Name:          demo-secret

Namespace:      default
Labels:             <none>
Annotations:
Type:               Opaque

Data
====
magicWord: 5   bytes

សូមចំណាំថាទិន្នន័យខ្លួនឯងមិនត្រូវបានបង្ហាញទេ។ វត្ថុសម្ងាត់នៅក្នុង Kubernetes ជាប្រភេទ Opaque ដែលមានន័យថាខ្លឹមសាររបស់វាមិនត្រូវបានបង្ហាញនៅក្នុង kubectl ពណ៌នាអំពីលទ្ធផល ធាតុចូល ឬស្ថានីយ ដែលធ្វើឱ្យវាមិនអាចបង្ហាញព័ត៌មានរសើបដោយចៃដន្យបានទេ។

ដើម្បីមើលកំណែ YAML ដែលបានអ៊ិនកូដនៃទិន្នន័យរសើប សូមប្រើពាក្យបញ្ជា kubectl get៖

kubectl get secret/demo-secret -o yaml
apiVersion: v1
data:
   magicWord: eHl6enk=
kind: Secret
metadata:
...
type: Opaque

មូលដ្ឋាន 64

តើអ្វីទៅជា eHl6enk= ខុសគ្នាទាំងស្រុងពីតម្លៃដើមរបស់យើង? នេះពិតជាវត្ថុសម្ងាត់ ដែលតំណាងឱ្យការអ៊ិនកូដ base64 ។ Base64 គឺជាគ្រោងការណ៍សម្រាប់ការអ៊ិនកូដទិន្នន័យគោលពីរតាមអំពើចិត្តជាខ្សែអក្សរ។

ដោយសារតែព័ត៌មានរសើបអាចជាប្រព័ន្ធគោលពីរ និងមិនមែនជាលទ្ធផល (ដូចករណីជាមួយសោអ៊ិនគ្រីប TLS) វត្ថុសម្ងាត់តែងតែត្រូវបានរក្សាទុកជាទម្រង់ base64។

អត្ថបទ beHl6enk= គឺជាកំណែដែលបានអ៊ិនកូដ base64 នៃពាក្យសំងាត់ xyzzy របស់យើង។ អ្នកអាចផ្ទៀងផ្ទាត់វាដោយដំណើរការពាក្យបញ្ជា base64 —ឌិកូដនៅក្នុងស្ថានីយ៖

echo "eHl6enk=" | base64 --decode
xyzzy

ដូច្នេះ ខណៈពេលដែល Kubernetes ការពារអ្នកពីការបញ្ចេញទិន្នន័យរសើបដោយចៃដន្យនៅក្នុងស្ថានីយ ឬឯកសារកំណត់ហេតុ ប្រសិនបើអ្នកបានអានការអនុញ្ញាតលើវត្ថុសម្ងាត់ក្នុងចន្លោះឈ្មោះជាក់លាក់ ទិន្នន័យនោះអាចជាមូលដ្ឋាន 64ed ហើយត្រូវបានឌិកូដជាបន្តបន្ទាប់។

ប្រសិនបើអ្នកត្រូវការបំប្លែង base64 អត្ថបទមួយចំនួន (ឧទាហរណ៍ ដើម្បីដាក់វាក្នុងសម្ងាត់) ប្រើពាក្យបញ្ជា base64 ដោយគ្មានអំណះអំណាង៖

echo xyzzy | base64
eHl6enkK

ការចូលប្រើវត្ថុសម្ងាត់

តើអ្នកណាអាចអាន និងកែសម្រួលវត្ថុសម្ងាត់? នេះត្រូវបានកំណត់ដោយ RBAC ដែលជាយន្តការគ្រប់គ្រងការចូលដំណើរការ (យើងនឹងពិភាក្សាវាយ៉ាងលម្អិតនៅក្នុងផ្នែករង "ការណែនាំអំពីការគ្រប់គ្រងការចូលប្រើដោយផ្អែកលើតួនាទី" នៅទំព័រ 258)។ ប្រសិនបើអ្នកកំពុងដំណើរការចង្កោមដែលមិនមាន RBAC ឬមិនត្រូវបានបើក វត្ថុសម្ងាត់ទាំងអស់របស់អ្នកមានសម្រាប់អ្នកប្រើប្រាស់ និងកុងតឺន័រណាមួយ (យើងនឹងពន្យល់នៅពេលក្រោយថាអ្នកមិនគួរមានចង្កោមផលិតកម្មណាមួយដោយគ្មាន RBAC)។

ការអ៊ិនគ្រីបទិន្នន័យអកម្ម

ចុះអ្នកដែលមានសិទ្ធិចូលប្រើមូលដ្ឋានទិន្នន័យ etcd ដែល Kubernetes រក្សាទុកព័ត៌មានទាំងអស់របស់វា? តើពួកគេអាចអានទិន្នន័យរសើបដោយមិនមានសិទ្ធិអានវត្ថុសម្ងាត់តាមរយៈ API បានទេ?

ចាប់តាំងពីកំណែ 1.7 មក Kubernetes គាំទ្រការអ៊ិនគ្រីបទិន្នន័យអកម្ម។ នេះមានន័យថាព័ត៌មានរសើបនៅខាងក្នុង etcd ត្រូវបានរក្សាទុកដោយអ៊ិនគ្រីបនៅលើថាស ហើយមិនអាចអានដោយអ្នកដែលមានសិទ្ធិចូលប្រើមូលដ្ឋានទិន្នន័យដោយផ្ទាល់។ ដើម្បីឌិគ្រីបវា អ្នកត្រូវការសោដែលមានតែម៉ាស៊ីនមេ Kubernetes API ប៉ុណ្ណោះ។ នៅក្នុងចង្កោមដែលបានកំណត់រចនាសម្ព័ន្ធត្រឹមត្រូវ ការអ៊ិនគ្រីបអកម្មគួរតែត្រូវបានបើក។

អ្នកអាចពិនិត្យមើលថាតើការអ៊ិនគ្រីបអកម្មដំណើរការនៅក្នុងចង្កោមរបស់អ្នកតាមវិធីនេះដែរឬទេ៖

kubectl describe pod -n kube-system -l component=kube-apiserver |grep encryption
        --experimental-encryption-provider-config=...

ប្រសិនបើអ្នកមិនឃើញទង់ពិសោធន៍-អ៊ិនគ្រីប-ផ្តល់-កំណត់រចនាសម្ព័ន្ធ ការអ៊ិនគ្រីបអកម្មមិនត្រូវបានបើកទេ។ នៅពេលប្រើ Google Kubernetes Engine ឬសេវាកម្មគ្រប់គ្រង Kubernetes ផ្សេងទៀត ទិន្នន័យរបស់អ្នកត្រូវបានអ៊ិនគ្រីបដោយប្រើយន្តការផ្សេង ដូច្នេះទង់នឹងមិនមានវត្តមានទេ។ ពិនិត្យជាមួយអ្នកលក់ Kubernetes របស់អ្នក ដើម្បីមើលថាតើមាតិកា etcd ត្រូវបានអ៊ិនគ្រីបឬអត់។

ការរក្សាទុកទិន្នន័យសម្ងាត់

មានធនធាន Kubernetes មួយចំនួនដែលមិនគួរត្រូវបានដកចេញពីចង្កោម ដូចជាវត្ថុសម្ងាត់ដែលមានភាពរសើបខ្លាំង។ អ្នកអាចការពារធនធានពីការលុបដោយប្រើចំណារពន្យល់ដែលផ្តល់ដោយអ្នកគ្រប់គ្រង Helm៖

kind: Secret
metadata:
    annotations:
        "helm.sh/resource-policy": keep

យុទ្ធសាស្ត្រគ្រប់គ្រងវត្ថុសម្ងាត់

នៅក្នុងឧទាហរណ៍ពីផ្នែកមុន ទិន្នន័យរសើបត្រូវបានការពារពីការចូលដោយគ្មានការអនុញ្ញាតភ្លាមៗបន្ទាប់ពីត្រូវបានរក្សាទុកនៅក្នុងចង្កោម។ ប៉ុន្តែនៅក្នុងឯកសារ manifest ពួកគេត្រូវបានរក្សាទុកជាអត្ថបទធម្មតា។

អ្នកមិនគួរដាក់ព័ត៌មានសម្ងាត់នៅក្នុងឯកសារដែលស្ថិតក្នុងការគ្រប់គ្រងកំណែទេ។ តើអ្នកអាចគ្រប់គ្រង និងរក្សាទុកព័ត៌មាននេះដោយសុវត្ថិភាពដោយរបៀបណា មុនពេលអនុវត្តវាទៅក្រុម Kubernetes របស់អ្នក?

អ្នកអាចជ្រើសរើសឧបករណ៍ ឬយុទ្ធសាស្ត្រណាមួយសម្រាប់គ្រប់គ្រងទិន្នន័យរសើបនៅក្នុងកម្មវិធីរបស់អ្នក ប៉ុន្តែអ្នកនឹងនៅតែត្រូវឆ្លើយយ៉ាងហោចណាស់សំណួរខាងក្រោម។

• តើ​ទិន្នន័យ​រសើប​គួរ​រក្សាទុក​នៅ​កន្លែង​ណា ដើម្បី​ឱ្យ​វា​អាច​ចូល​ប្រើប្រាស់​បាន​ខ្ពស់?
• តើធ្វើដូចម្តេចដើម្បីធ្វើឱ្យទិន្នន័យរសើបអាចចូលប្រើបានចំពោះកម្មវិធីសកម្មរបស់អ្នក?
• តើមានអ្វីកើតឡើងចំពោះកម្មវិធីរបស់អ្នក នៅពេលអ្នកជំនួស ឬកែសម្រួលទិន្នន័យរសើប?

អំពីអ្នកនិពន្ធ

លោក John Arundel ជាអ្នកប្រឹក្សាដែលមានបទពិសោធន៍ 30 ឆ្នាំនៅក្នុងឧស្សាហកម្មកុំព្យូទ័រ។ គាត់បានសរសេរសៀវភៅជាច្រើនក្បាល និងធ្វើការជាមួយក្រុមហ៊ុនជាច្រើនមកពីប្រទេសផ្សេងៗគ្នា ដោយណែនាំពួកគេអំពីហេដ្ឋារចនាសម្ព័ន្ធដែលមានមូលដ្ឋានលើពពក និង Kubernetes ។ ពេលទំនេរ គាត់ចូលចិត្តលេងកីឡាវាយកូនបាល់ ជាអ្នកបាញ់កាំភ្លើងល្អ និងលេងព្យាណូក្នុងនាមជាអ្នកស្ម័គ្រចិត្ត។ រស់នៅក្នុងខ្ទមទេពអប្សរក្នុងទីក្រុង Cornwall ប្រទេសអង់គ្លេស។

Justin Domingus - វិស្វករគ្រប់គ្រងប្រព័ន្ធដែលធ្វើការនៅក្នុងបរិយាកាស DevOps ជាមួយ Kubernetes និងបច្ចេកវិទ្យាពពក។ គាត់ចូលចិត្តចំណាយពេលនៅខាងក្រៅ ផឹកកាហ្វេ ក្តាម និងអង្គុយនៅកុំព្យូទ័រ។ រស់នៅក្នុងទីក្រុង Seattle រដ្ឋ Washington ជាមួយនឹងឆ្មាដ៏អស្ចារ្យមួយក្បាល និងភរិយាដ៏អស្ចារ្យ និងមិត្តល្អបំផុតគឺ Adrienne ។

» ព័ត៌មានលំអិតអំពីសៀវភៅ អាចរកបាននៅ គេហទំព័ររបស់អ្នកបោះពុម្ពផ្សាយ
» តារាងមាតិកា
» សម្រង់

សម្រាប់ Khabrozhiteley ការបញ្ចុះតម្លៃ 25% ដោយប្រើប័ណ្ណ - Kubernetes

នៅពេលបង់ថ្លៃក្រដាស សៀវភៅអេឡិចត្រូនិចនឹងត្រូវបានផ្ញើតាមអ៊ីមែល។

ប្រភព: www.habr.com