എഴുതി കുറച്ചു സമയം കഴിഞ്ഞു ആദ്യ ലേഖനം, ഞാൻ jsonnet ഉം gitlab ഉം സമർത്ഥമായി കൈകാര്യം ചെയ്യുന്നിടത്ത്, പൈപ്പ് ലൈനുകൾ തീർച്ചയായും നല്ലതാണെന്നും എന്നാൽ അനാവശ്യമായി സങ്കീർണ്ണവും അസൗകര്യമുള്ളതുമാണെന്ന് ഞാൻ മനസ്സിലാക്കി.

മിക്ക കേസുകളിലും, ഒരു സാധാരണ ടാസ്ക് ആവശ്യമാണ്: "YAML സൃഷ്ടിച്ച് കുബർനെറ്റസിൽ ഇടുക." യഥാർത്ഥത്തിൽ, ഇതാണ് ആർഗോ സിഡി ശ്രദ്ധേയമായി ചെയ്യുന്നത്.

ഒരു Git റിപ്പോസിറ്ററി കണക്റ്റുചെയ്യാനും അതിന്റെ അവസ്ഥ കുബർനെറ്റസിലേക്ക് അയയ്ക്കാനും Argo CD നിങ്ങളെ അനുവദിക്കുന്നു. സ്ഥിരസ്ഥിതിയായി, നിരവധി തരത്തിലുള്ള ആപ്ലിക്കേഷനുകൾക്കുള്ള പിന്തുണയുണ്ട്: കസ്റ്റമൈസ്, ഹെൽം ചാർട്ടുകൾ, ക്‌സോണറ്റ്, ബെയർ ജെസോനെറ്റ് അല്ലെങ്കിൽ YAML/JSON മാനിഫെസ്റ്റുകളുള്ള ഡയറക്ടറികൾ.

ഈ സെറ്റ് മിക്ക ഉപയോക്താക്കൾക്കും മതിയാകും, എന്നാൽ എല്ലാവർക്കും അല്ല. എല്ലാവരുടെയും ആവശ്യങ്ങൾ നിറവേറ്റുന്നതിനായി, ആർഗോ സിഡിക്ക് ഇഷ്‌ടാനുസൃത ടൂളിംഗ് ഉപയോഗിക്കാനുള്ള കഴിവുണ്ട്.

ഒന്നാമതായി, പിന്തുണ ചേർക്കുന്നതിനുള്ള സാധ്യതയിൽ എനിക്ക് താൽപ്പര്യമുണ്ട് qbec и git-crypt, മുൻ ലേഖനത്തിൽ പൂർണ്ണമായി ചർച്ച ചെയ്തവ.

നിങ്ങൾ കോൺഫിഗറേഷൻ ആരംഭിക്കുന്നതിന് മുമ്പ്, ആർഗോ സിഡി എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്ന് നിങ്ങൾ ആദ്യം മനസ്സിലാക്കേണ്ടതുണ്ട്.

ചേർത്ത ഓരോ ആപ്ലിക്കേഷനും രണ്ട് ഘട്ടങ്ങളുണ്ട്:

ഇവയെ — വിന്യാസത്തിനു മുമ്പുള്ള പ്രാരംഭ തയ്യാറെടുപ്പ്, ഇവിടെ എന്തും സംഭവിക്കാം: ഡിപൻഡൻസികൾ ഡൗൺലോഡ് ചെയ്യുക, രഹസ്യങ്ങൾ അൺപാക്ക് ചെയ്യുക എന്നിവയും മറ്റും.
ജനറേറ്റ് — നേരിട്ട് മാനിഫെസ്റ്റ് ജനറേഷൻ കമാൻഡ് എക്സിക്യൂട്ട് ചെയ്യുന്നു, ഔട്ട്പുട്ട് ഒരു സാധുവായ YAML സ്ട്രീം ആയിരിക്കണം, ഇതാണ് ക്ലസ്റ്ററിലേക്ക് പ്രയോഗിക്കുന്നത്.

ഹെൽം ഉൾപ്പെടെ ഏത് തരത്തിലുള്ള ആപ്ലിക്കേഷനിലും ആർഗോ ഈ സമീപനം പ്രയോഗിക്കുന്നു എന്നതാണ് ശ്രദ്ധേയമായ കാര്യം. അതായത്, ആർഗോ സിഡിയിൽ ഹെൽം ക്ലസ്റ്ററിലേക്ക് റിലീസുകൾ വിന്യസിക്കുന്നില്ല, മറിച്ച് മാനിഫെസ്റ്റുകൾ സൃഷ്ടിക്കാൻ മാത്രമാണ് ഉപയോഗിക്കുന്നത്.

അതിന്റെ ഭാഗമായി, ആർഗോയ്ക്ക് ഹെൽം ഹുക്കുകൾ നേറ്റീവ് ആയി പ്രോസസ്സ് ചെയ്യാൻ കഴിയും, ഇത് റിലീസുകൾ പ്രയോഗിക്കുന്നതിന്റെ യുക്തി ലംഘിക്കാതിരിക്കാൻ അനുവദിക്കുന്നു.

ക്യുബിഇസി

jsonnet ഉപയോഗിച്ചുള്ള ആപ്ലിക്കേഷനുകൾ സൗകര്യപ്രദമായി വിവരിക്കാൻ Qbec നിങ്ങളെ അനുവദിക്കുന്നു, കൂടാതെ ഹെൽം ചാർട്ടുകൾ റെൻഡർ ചെയ്യാനുള്ള കഴിവും ഉണ്ട്, കൂടാതെ Argo CD ന് സാധാരണയായി Helm ഹുക്കുകൾ പ്രോസസ്സ് ചെയ്യാൻ കഴിയുമെന്നതിനാൽ, Argo CD ഉപയോഗിച്ച് ഈ സവിശേഷത ഉപയോഗിക്കുന്നത് കൂടുതൽ ശരിയായ ഫലങ്ങൾ നേടാൻ നിങ്ങളെ അനുവദിക്കുന്നു.

qbec പിന്തുണ argocd-ലേക്ക് ചേർക്കുന്നതിന് നിങ്ങൾക്ക് രണ്ട് കാര്യങ്ങൾ ആവശ്യമാണ്:

ആർഗോ സിഡി കോൺഫിഗറിൽ, നിങ്ങളുടെ ഇഷ്‌ടാനുസൃത പ്ലഗിനും മാനിഫെസ്റ്റുകൾ സൃഷ്‌ടിക്കുന്നതിനുള്ള കമാൻഡുകളും നിർവചിച്ചിരിക്കണം.
ആവശ്യമായ ബൈനറികൾ ചിത്രത്തിൽ ലഭ്യമായിരിക്കണം ആർഗോസിഡി-റിപ്പോ-സെർവർ.

ആദ്യ ചുമതല തീരുമാനിക്കുകയാണ് വളരെ ലളിതം:

# cm.yaml
data:
  configManagementPlugins: |
    - name: qbec
      generate:
        command: [sh, -xc]
        args: ['qbec show "$ENVIRONMENT" -S --force:k8s-namespace "$ARGOCD_APP_NAMESPACE"']

(ടീം ഇവയെ ഉപയോഗിച്ചിട്ടില്ല)

$ kubectl -n argocd patch cm/argocd-cm -p "$(cat cm.yaml)"

ബൈനറികൾ ചേർക്കാൻ നിർദ്ദേശിക്കുന്നു ഒരു പുതിയ ചിത്രം ശേഖരിക്കുക, അല്ലെങ്കിൽ ഉപയോഗിക്കുക init കണ്ടെയ്നർ ട്രിക്ക്:

# deploy.yaml
spec:
  template:
    spec:
      # 1. Define an emptyDir volume which will hold the custom binaries
      volumes:
      - name: custom-tools
        emptyDir: {}
      # 2. Use an init container to download/copy custom binaries into the emptyDir
      initContainers:
      - name: download-tools
        image: alpine:3.12
        command: [sh, -c]
        args:
        - wget -qO- https://github.com/splunk/qbec/releases/download/v0.12.2/qbec-linux-amd64.tar.gz | tar -xvzf - -C /custom-tools/
        volumeMounts:
        - mountPath: /custom-tools
          name: custom-tools
      # 3. Volume mount the custom binary to the bin directory (overriding the existing version)
      containers:
      - name: argocd-repo-server
        volumeMounts:
        - mountPath: /usr/local/bin/qbec
          name: custom-tools
          subPath: qbec
        - mountPath: /usr/local/bin/jsonnet-qbec
          name: custom-tools
          subPath: jsonnet-qbec

$ kubectl -n argocd patch deploy/argocd-repo-server -p "$(cat deploy.yaml)"

ഇപ്പോൾ നമ്മുടെ ആപ്ലിക്കേഷൻ മാനിഫെസ്റ്റ് എങ്ങനെയായിരിക്കുമെന്ന് നോക്കാം:

apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: qbec-app
  namespace: argocd
spec:
  destination: 
    namespace: default
    server: https://kubernetes.default.svc
  project: default
  source: 
    path: qbec-app
    plugin: 
      env: 
        - name: ENVIRONMENT
          value: default
      name: qbec
    repoURL: https://github.com/kvaps/argocd-play
  syncPolicy: 
    automated: 
      prune: true

ഒരു വേരിയബിളിൽ ENVIRONMENT മാനിഫെസ്റ്റുകൾ സൃഷ്ടിക്കേണ്ട പരിസ്ഥിതിയുടെ പേര് ഞങ്ങൾ കൈമാറുന്നു.

നമുക്ക് ഇത് പ്രയോഗിച്ച് നമുക്ക് എന്താണ് ലഭിക്കുന്നതെന്ന് നോക്കാം:

ആപ്ലിക്കേഷൻ വിന്യസിച്ചു, കൊള്ളാം!

git-crypt

നിങ്ങളുടെ റിപ്പോസിറ്ററിക്കായി സുതാര്യമായ എൻക്രിപ്ഷൻ സജ്ജീകരിക്കാൻ Git-crypt നിങ്ങളെ അനുവദിക്കുന്നു. സെൻസിറ്റീവ് ഡാറ്റ നേരിട്ട് git-ൽ സംഭരിക്കുന്നതിനുള്ള ലളിതവും സുരക്ഷിതവുമായ മാർഗമാണിത്.

ജിറ്റ്-ക്രിപ്റ്റ് നടപ്പിലാക്കുന്നത് കൂടുതൽ ബുദ്ധിമുട്ടുള്ളതായി മാറി.

സൈദ്ധാന്തികമായി നമുക്ക് ചെയ്യാൻ കഴിയും git-crypt unlock ഞങ്ങളുടെ ഇഷ്‌ടാനുസൃത പ്ലഗിന്റെ init ഘട്ടത്തിൽ, പക്ഷേ ഇത് വളരെ സൗകര്യപ്രദമല്ല, കാരണം ഇത് നേറ്റീവ് വിന്യാസ രീതികൾ ഉപയോഗിക്കാൻ അനുവദിക്കില്ല. ഉദാഹരണത്തിന്, ഹെൽമിന്റെയും ജെസോണറ്റിന്റെയും കാര്യത്തിൽ, ആപ്ലിക്കേഷൻ കോൺഫിഗറേഷൻ (മൂല്യ ഫയലുകൾ മുതലായവ) ലളിതമാക്കാൻ ഞങ്ങളെ അനുവദിക്കുന്ന ഒരു ഫ്ലെക്സിബിൾ ജിയുഐ ഇന്റർഫേസ് ഞങ്ങൾക്ക് നഷ്‌ടപ്പെടും.

അതുകൊണ്ടാണ് ക്ലോണിംഗ് സമയത്ത് ശേഖരം ആദ്യഘട്ടത്തിൽ അച്ചടിക്കാൻ ഞാൻ ആഗ്രഹിച്ചത്.

ശേഖരം സമന്വയിപ്പിക്കുന്നതിനുള്ള ഹുക്കുകളൊന്നും വിവരിക്കാനുള്ള കഴിവ് ഇപ്പോൾ ആർഗോ സിഡി നൽകുന്നില്ല എന്നതിനാൽ, ജിറ്റ് കമാൻഡിന് പകരം വയ്ക്കുന്ന ഒരു തന്ത്രപരമായ ഷെൽ സ്ക്രിപ്റ്റ് ഉപയോഗിച്ച് ഞങ്ങൾക്ക് ഈ പരിമിതി മറികടക്കേണ്ടി വന്നു:

#!/bin/sh
$(dirname $0)/git.bin "$@"
ec=$?
[ "$1" = fetch ] && [ -d .git-crypt ] || exit $ec
GNUPGHOME=/app/config/gpg/keys git-crypt unlock 2>/dev/null
exit $ec

ആർഗോ സിഡി നിർവഹിക്കുന്നു git fetch വിന്യാസ പ്രവർത്തനത്തിന് മുമ്പ് ഓരോ തവണയും. ഈ കമാൻഡാണ് ഞങ്ങൾ എക്സിക്യൂഷൻ നൽകുന്നത് git-crypt unlock ശേഖരം അൺലോക്ക് ചെയ്യാൻ.

ടെസ്റ്റുകൾക്കായി നിങ്ങൾക്ക് ഉപയോഗിക്കാം എന്റെ ഡോക്കർ ചിത്രം നിങ്ങൾക്ക് ആവശ്യമുള്ളതെല്ലാം ഇതിനകം ഉണ്ട്:

$ kubectl -n argocd set image deploy/argocd-repo-server argocd-repo-server=docker.io/kvaps/argocd-git-crypt:v1.7.3

ആർഗോ നമ്മുടെ ശേഖരണങ്ങളെ എങ്ങനെ ഡീക്രിപ്റ്റ് ചെയ്യുമെന്ന് ഇപ്പോൾ നമ്മൾ ചിന്തിക്കേണ്ടതുണ്ട്. അതായത്, അതിനായി ഒരു ജിപിജി കീ സൃഷ്ടിക്കുക:

$ kubectl exec -ti deploy/argocd-repo-server -- bash

$ printf "%sn" 
    "%no-protection" 
    "Key-Type: default" 
    "Subkey-Type: default" 
    "Name-Real: YOUR NAME" 
    "Name-Email: YOUR EMAIL@example.com" 
    "Expire-Date: 0" 
    > genkey-batch 

$ gpg --batch --gen-key genkey-batch
gpg: WARNING: unsafe ownership on homedir '/home/argocd/.gnupg'
gpg: keybox '/home/argocd/.gnupg/pubring.kbx' created
gpg: /home/argocd/.gnupg/trustdb.gpg: trustdb created
gpg: key 8CB8B24F50B4797D marked as ultimately trusted
gpg: directory '/home/argocd/.gnupg/openpgp-revocs.d' created
gpg: revocation certificate stored as '/home/argocd/.gnupg/openpgp-revocs.d/9A1FF8CAA917CE876E2562FC8CB8B24F50B4797D.rev'

നമുക്ക് കീ നാമം സംരക്ഷിക്കാം 8CB8B24F50B4797D തുടർ നടപടികൾക്കായി. കീ തന്നെ കയറ്റുമതി ചെയ്യുക:

$ gpg --list-keys
gpg: WARNING: unsafe ownership on homedir '/home/argocd/.gnupg'
/home/argocd/.gnupg/pubring.kbx
-------------------------------
pub   rsa3072 2020-09-04 [SC]
      9A1FF8CAA917CE876E2562FC8CB8B24F50B4797D
uid           [ultimate] YOUR NAME <YOUR EMAIL@example.com>
sub   rsa3072 2020-09-04 [E]

$ gpg --armor --export-secret-keys 8CB8B24F50B4797D

കൂടാതെ ഇത് ഒരു പ്രത്യേക രഹസ്യമായി ചേർക്കുക:

# argocd-gpg-keys-secret.yaml
apiVersion: v1
kind: Secret
metadata:
  name: argocd-gpg-keys-secret
  namespace: argocd
stringData:
  8CB8B24F50B4797D: |-
    -----BEGIN PGP PRIVATE KEY BLOCK-----

    lQVYBF9Q8KUBDACuS4p0ctXoakPLqE99YLmdixfF/QIvXVIG5uBXClWhWMuo+D0c
    ZfeyC5GvH7XPUKz1cLMqL6o/u9oHJVUmrvN/g2Mnm365nTGw1M56AfATS9IBp0HH
    O/fbfiH6aMWmPrW8XIA0icoOAdP+bPcBqM4HRo4ssbRS9y/i
    =yj11
    -----END PGP PRIVATE KEY BLOCK-----

$ kubectl apply -f argocd-gpg-keys-secret.yaml

അത് കണ്ടെയ്നറിലേക്ക് എറിയുക മാത്രമാണ് ഞങ്ങൾക്ക് അവശേഷിക്കുന്നത് ആർഗോസിഡി-റിപ്പോ-സെർവർ, ഇത് ചെയ്യുന്നതിന്, വിന്യാസം എഡിറ്റ് ചെയ്യുക:

$ kubectl -n argocd edit deploy/argocd-repo-server

ഞങ്ങൾ നിലവിലുള്ളത് മാറ്റിസ്ഥാപിക്കും gpg-കീകൾ വോളിയം ഓൺ projected, അവിടെ ഞങ്ങൾ ഞങ്ങളുടെ രഹസ്യം സൂചിപ്പിക്കുന്നു:

   spec:
     template:
       spec:
         volumes:
         - name: gpg-keys
           projected:
             defaultMode: 420
             sources:
             - secret:
                 name: argocd-gpg-keys-secret
             - configMap:
                 name: argocd-gpg-keys-cm

കണ്ടെയ്‌നർ ആരംഭിക്കുമ്പോൾ Argo CD ഈ ഡയറക്‌ടറിയിൽ നിന്ന് gpg കീകൾ സ്വയമേവ ലോഡ് ചെയ്യുന്നു, അതിനാൽ ഇത് ഞങ്ങളുടെ സ്വകാര്യ കീയും ലോഡ് ചെയ്യും.

നമുക്ക് പരിശോധിക്കാം:

$ kubectl -n argocd exec -ti deploy/argocd-repo-server -- bash
$ GNUPGHOME=/app/config/gpg/keys gpg --list-secret-keys
gpg: WARNING: unsafe ownership on homedir '/app/config/gpg/keys'
/app/config/gpg/keys/pubring.kbx
--------------------------------
sec   rsa2048 2020-09-05 [SC] [expires: 2021-03-04]
      ED6285A3B1A50B6F1D9C955E5E8B1B16D47FFC28
uid           [ultimate] Anon Ymous (ArgoCD key signing key) <noreply@argoproj.io>

sec   rsa3072 2020-09-03 [SC]
      9A1FF8CAA917CE876E2562FC8CB8B24F50B4797D
uid           [ultimate] YOUR NAME <YOUR EMAIL@example.com>
ssb   rsa3072 2020-09-03 [E]

കൊള്ളാം, കീ ലോഡ് ചെയ്തു! ഇപ്പോൾ ഒരു സഹകാരി എന്ന നിലയിൽ ആർഗോ സിഡി ഞങ്ങളുടെ ശേഖരത്തിലേക്ക് ചേർക്കേണ്ടതുണ്ട്, അത് ഈച്ചയിൽ സ്വയമേവ ഡീക്രിപ്റ്റ് ചെയ്യാൻ കഴിയും.

ലോക്കൽ കമ്പ്യൂട്ടറിലേക്ക് കീ ഇമ്പോർട്ടുചെയ്യുക:

$ gpg --armor --export-secret 8CB8B24F50B4797D > 8CB8B24F50B4797D.pem
$ gpg --import 8CB8B24F50B4797D.pem

നമുക്ക് ട്രസ്റ്റ് ലെവൽ സജ്ജമാക്കാം:

$ gpg --edit-key 8CB8B24F50B4797D
trust
5

ഞങ്ങളുടെ പ്രോജക്റ്റിലേക്ക് ഒരു സഹകാരിയായി ആർഗോയെ ചേർക്കാം:

$ git-crypt add-gpg-user 8CB8B24F50B4797D

ബന്ധപ്പെട്ട ലിങ്കുകൾ:

അവലംബം: www.habr.com

ആർഗോ സിഡിയിൽ കസ്റ്റം ടൂളിംഗ് മനസ്സിലാക്കുന്നു

ക്യുബിഇസി

git-crypt