കുബർനെറ്റസ് നുറുങ്ങുകളും തന്ത്രങ്ങളും: പ്രാദേശിക വികസനത്തെക്കുറിച്ചും ടെലിപ്രെസൻസെക്കുറിച്ചും

Kubernetes-ൽ മൈക്രോസർവീസുകൾ വികസിപ്പിക്കുന്നതിനെക്കുറിച്ച് ഞങ്ങളോട് കൂടുതലായി ചോദിക്കുന്നു. ഡെവലപ്പർമാർ, പ്രത്യേകിച്ച് വ്യാഖ്യാനിച്ച ഭാഷകൾ, അവരുടെ പ്രിയപ്പെട്ട IDE-യിലെ കോഡ് വേഗത്തിൽ ശരിയാക്കാനും ബിൽഡ്/വിന്യാസത്തിനായി കാത്തിരിക്കാതെ ഫലം കാണാനും ആഗ്രഹിക്കുന്നു - F5 അമർത്തിക്കൊണ്ട്. ഒരു മോണോലിത്തിക്ക് ആപ്ലിക്കേഷന്റെ കാര്യം വരുമ്പോൾ, പ്രാദേശികമായി ഒരു ഡാറ്റാബേസും ഒരു വെബ് സെർവറും (ഡോക്കറിൽ, വെർച്വൽബോക്സിൽ...) ഇൻസ്റ്റാൾ ചെയ്താൽ മതിയായിരുന്നു, തുടർന്ന് ഉടൻ തന്നെ വികസനം ആസ്വദിക്കൂ. മോണോലിത്തുകൾ മൈക്രോസർവീസുകളാക്കി മുറിച്ച് കുബർനെറ്റസിന്റെ വരവോടെ, പരസ്പരം ആശ്രിതത്വം പ്രത്യക്ഷപ്പെടുന്നതോടെ, എല്ലാം അത് കുറച്ചുകൂടി ബുദ്ധിമുട്ടായി. ഈ മൈക്രോസർവീസുകൾ കൂടുതൽ, കൂടുതൽ പ്രശ്നങ്ങൾ. വികസനം വീണ്ടും ആസ്വദിക്കാൻ, നിങ്ങൾ ഒന്നോ രണ്ടോ ഡോക്കർ കണ്ടെയ്‌നറുകളിൽ കൂടുതൽ ഉയർത്തേണ്ടതുണ്ട്, ചിലപ്പോൾ ഒരു ഡസനിലധികം... പൊതുവേ, ഇതിനെല്ലാം വളരെയധികം സമയമെടുക്കും, കാരണം ഇത് കാലികമായി നിലനിർത്തേണ്ടതുണ്ട്. .

വ്യത്യസ്ത സമയങ്ങളിൽ ഞങ്ങൾ പ്രശ്നത്തിന് വ്യത്യസ്ത പരിഹാരങ്ങൾ പരീക്ഷിച്ചു. കുമിഞ്ഞുകൂടിയ പരിഹാരങ്ങൾ അല്ലെങ്കിൽ "ക്രച്ചുകൾ" ഉപയോഗിച്ച് ഞാൻ ആരംഭിക്കും.

1. ഊന്നുവടികൾ

മിക്ക IDE-കൾക്കും FTP/SFTP ഉപയോഗിച്ച് സെർവറിൽ നേരിട്ട് കോഡ് എഡിറ്റ് ചെയ്യാനുള്ള കഴിവുണ്ട്. ഈ പാത വളരെ വ്യക്തമാണ്, ഞങ്ങൾ അത് ഉപയോഗിക്കാൻ ഉടൻ തീരുമാനിച്ചു. അതിന്റെ സാരാംശം ഇനിപ്പറയുന്നതിലേക്ക് ചുരുങ്ങുന്നു:

1. ഡെവലപ്‌മെന്റ് എൻവയോൺമെന്റുകളുടെ പോഡിൽ (dev/review), SSH ആക്‌സസ് ഉള്ള ഒരു അധിക കണ്ടെയ്‌നർ സമാരംഭിക്കുകയും ഡെവലപ്പറുടെ പൊതു SSH കീ ഫോർവേഡ് ചെയ്യുകയും ചെയ്യുന്നു.
2. init ഘട്ടത്തിൽ (കണ്ടെയ്നറിനുള്ളിൽ prepare-app) എന്നതിലേക്ക് കോഡ് കൈമാറുക emptyDirആപ്ലിക്കേഷൻ കണ്ടെയ്‌നറുകളിൽ നിന്നും SSH സെർവറിൽ നിന്നും കോഡിലേക്ക് ആക്‌സസ് ലഭിക്കുന്നതിന്.

അത്തരമൊരു സ്കീമിന്റെ സാങ്കേതിക നിർവ്വഹണം നന്നായി മനസ്സിലാക്കാൻ, കുബെർനെറ്റസിൽ ഉൾപ്പെട്ടിരിക്കുന്ന YAML കോൺഫിഗറേഷനുകളുടെ ശകലങ്ങൾ ഞാൻ നൽകും.

കോൺഫിഗറേഷനുകൾ

1.1 മൂല്യങ്ങൾ.yaml

ssh_pub_key:
  vasya.pupkin: <ssh public key in base64> 

ഇത് vasya.pupkin വേരിയബിളിന്റെ മൂല്യമാണ് ${GITLAB_USER_LOGIN}.

1.2 deployment.yaml

...
{{ if eq .Values.global.debug "yes" }}
      volumes:
      - name: ssh-pub-key
        secret:
          defaultMode: 0600
          secretName: {{ .Chart.Name }}-ssh-pub-key
      - name: app-data
        emptyDir: {}
      initContainers:
      - name: prepare-app
{{ tuple "backend" . | include "werf_container_image" | indent 8 }}
        volumeMounts:
        - name: app-data
          mountPath: /app-data
        command: ["bash", "-c", "cp -ar /app/* /app-data/" ]
{{ end }}
      containers:
{{ if eq .Values.global.debug "yes" }}
      - name: ssh
        image: corbinu/ssh-server
        volumeMounts:
        - name: ssh-pub-key
          readOnly: true
          mountPath: /root/.ssh/authorized_keys
          subPath: authorized_keys
        - name: app-data
          mountPath: /app
        ports:
        - name: ssh
          containerPort: 22
          protocol: TCP
{{ end }}
      - name: backend
        volumeMounts:
{{ if eq .Values.global.debug "yes" }}
        - name: app-data
          mountPath: /app
{{ end }}
        command: ["/usr/sbin/php-fpm7.2", "--fpm-config", "/etc/php/7.2/php-fpm.conf", "-F"]
...

1.3 രഹസ്യം.yaml

{{ if eq .Values.global.debug "yes" }}
apiVersion: v1
kind: Secret
metadata:
  name: {{ .Chart.Name }}-ssh-pub-key
type: Opaque
data:
  authorized_keys: "{{ first (pluck .Values.global.username .Values.ssh_pub_key) }}"
{{ end }}

അന്തിമ സ്‌പർശനം

അതിനുശേഷം കൈമാറ്റം മാത്രമാണ് അവശേഷിക്കുന്നത് gitlab-ci.yml വേരിയബിളുകൾ ആവശ്യമാണ്:

dev:
  stage: deploy
  script:
   - type multiwerf && source <(multiwerf use 1.0 beta)
   - type werf && source <(werf ci-env gitlab --tagging-strategy tag-or-branch --verbose)
   - werf deploy
     --namespace ${CI_PROJECT_NAME}-stage
     --set "global.env=stage"
     --set "global.git_rev=${CI_COMMIT_SHA}"
     --set "global.debug=yes"
     --set "global.username=${GITLAB_USER_LOGIN}"
 tags:
   - build

Voila: വിന്യാസം ആരംഭിച്ച ഡവലപ്പർക്ക് സേവന നാമം ഉപയോഗിച്ച് കണക്റ്റുചെയ്യാനാകും (ക്ലസ്റ്ററിലേക്ക് എങ്ങനെ സുരക്ഷിതമായി ആക്സസ് അനുവദിക്കാം, ഞങ്ങൾ ഇതിനകം പറഞ്ഞു) നിങ്ങളുടെ ഡെസ്‌ക്‌ടോപ്പിൽ നിന്ന് SFTP വഴി കോഡ് ക്ലസ്റ്ററിലേക്ക് കൈമാറുന്നത് വരെ കാത്തിരിക്കാതെ എഡിറ്റ് ചെയ്യുക.

ഇത് പൂർണ്ണമായും പ്രവർത്തനക്ഷമമായ ഒരു പരിഹാരമാണ്, എന്നാൽ നടപ്പാക്കൽ വീക്ഷണകോണിൽ നിന്ന് ഇതിന് വ്യക്തമായ ദോഷങ്ങളുണ്ട്:

• ഭാവിയിൽ വായിക്കാൻ ബുദ്ധിമുട്ടുള്ള ഹെൽം ചാർട്ട് പരിഷ്കരിക്കേണ്ടതിന്റെ ആവശ്യകത;
• സേവനം വിന്യസിച്ച വ്യക്തിക്ക് മാത്രമേ ഉപയോഗിക്കാൻ കഴിയൂ;
• കോഡുമായി ലോക്കൽ ഡയറക്ടറിയുമായി സമന്വയിപ്പിക്കാനും അത് Git-ലേക്ക് സമർപ്പിക്കാനും നിങ്ങൾ ഓർമ്മിക്കേണ്ടതുണ്ട്.

2. ടെലിപ്രസൻസ്

പദ്ധതി ടെലിപ്രസൻസ് വളരെക്കാലമായി അറിയപ്പെടുന്നു, പക്ഷേ അവർ പറയുന്നതുപോലെ, "പ്രായോഗികമായി ഇത് ഗൗരവമായി പരീക്ഷിക്കാൻ ഞങ്ങൾ തയ്യാറായില്ല." എന്നിരുന്നാലും, ഡിമാൻഡ് അതിന്റെ ജോലി ചെയ്തു, ഇപ്പോൾ ഞങ്ങളുടെ അനുഭവം പങ്കിടുന്നതിൽ ഞങ്ങൾക്ക് സന്തോഷമുണ്ട്, ഇത് ഞങ്ങളുടെ ബ്ലോഗിന്റെ വായനക്കാർക്ക് ഉപയോഗപ്രദമാകും - പ്രത്യേകിച്ചും ടെലിപ്രസെൻസിനെക്കുറിച്ച് ഇതുവരെ മറ്റ് മെറ്റീരിയലുകളൊന്നും ഹബിൽ ഇല്ലാതിരുന്നതിനാൽ.

ചുരുക്കത്തിൽ, എല്ലാം അത്ര ഭയാനകമല്ലെന്ന് തെളിഞ്ഞു. ഡെവലപ്പറുടെ ഭാഗത്തുനിന്ന് നടപ്പിലാക്കേണ്ട എല്ലാ പ്രവർത്തനങ്ങളും ഞങ്ങൾ ഹെൽം ചാർട്ട് ടെക്സ്റ്റ് ഫയലിൽ സ്ഥാപിച്ചു NOTES.txt. അങ്ങനെ, കുബെർനെറ്റസിലേക്ക് സേവനം വിന്യസിച്ചതിന് ശേഷം, ഡെവലപ്പർ GitLab ജോലി ലോഗിൽ പ്രാദേശിക ദേവ പരിസ്ഥിതി സമാരംഭിക്കുന്നതിനുള്ള നിർദ്ദേശങ്ങൾ കാണുന്നു:

!!! Разработка сервиса локально, в составе Kubernetes !!!

* Настройка окружения
* * Должен быть доступ до кластера через VPN
* * На локальном ПК установлен kubectl ( https://kubernetes.io/docs/tasks/tools/install-kubectl/ )
* * Получить config-файл для kubectl (скопировать в ~/.kube/config)
* * На локальном ПК установлен telepresence ( https://www.telepresence.io/reference/install )
* * Должен быть установлен Docker
* * Необходим доступ уровня reporter или выше к репозиторию https://gitlab.site.com/group/app
* * Необходимо залогинится в registry с логином/паролем от GitLab (делается один раз):

#########################################################################
docker login registry.site.com
#########################################################################

* Запуск окружения

#########################################################################
telepresence --namespace {{ .Values.global.env }} --swap-deployment {{ .Chart.Name  }}:backend --mount=/tmp/app --docker-run -v `pwd`:/app -v /tmp/app/var/run/secrets:/var/run/secrets -ti registry.site.com/group/app/backend:v8
#########################################################################

ഈ നിർദ്ദേശത്തിൽ വിവരിച്ചിരിക്കുന്ന ഘട്ടങ്ങളിൽ ഞങ്ങൾ വിശദമായി വസിക്കില്ല ... അവസാനത്തേത് ഒഴികെ. ടെലിപ്രസൻസ് ലോഞ്ച് ചെയ്യുമ്പോൾ എന്താണ് സംഭവിക്കുന്നത്?

ടെലിപ്രസൻസുമായി പ്രവർത്തിക്കുന്നു

ആരംഭത്തിൽ (മുകളിലുള്ള നിർദ്ദേശങ്ങളിൽ വ്യക്തമാക്കിയ അവസാന കമാൻഡ് ഉപയോഗിച്ച്), ഞങ്ങൾ സജ്ജമാക്കുന്നു:

• മൈക്രോസർവീസ് പ്രവർത്തിക്കുന്ന നെയിംസ്പേസ്;
• ഞങ്ങൾ തുളച്ചുകയറാൻ ആഗ്രഹിക്കുന്ന വിന്യാസത്തിന്റെയും കണ്ടെയ്‌നറിന്റെയും പേരുകൾ.

ശേഷിക്കുന്ന ആർഗ്യുമെന്റുകൾ ഓപ്ഷണൽ ആണ്. ഞങ്ങളുടെ സേവനം Kubernetes API-യുമായി സംവദിക്കുകയാണെങ്കിൽ സേവന അക്കൗണ്ട് സൃഷ്ടിച്ചു, ഞങ്ങളുടെ ഡെസ്ക്ടോപ്പിൽ സർട്ടിഫിക്കറ്റുകൾ/ടോക്കണുകൾ മൗണ്ട് ചെയ്യേണ്ടതുണ്ട്. ഇത് ചെയ്യുന്നതിന്, ഓപ്ഷൻ ഉപയോഗിക്കുക --mount=true (അല്ലെങ്കിൽ --mount=/dst_path), ഇത് കുബർനെറ്റസ് കണ്ടെയ്‌നറിൽ നിന്ന് ഞങ്ങളുടെ ഡെസ്‌ക്‌ടോപ്പിലേക്ക് റൂട്ട് (/) മൗണ്ട് ചെയ്യും. ഇതിനുശേഷം, ക്ലസ്റ്ററിൽ നിന്നുള്ള "കീകൾ" നമുക്ക് (OS-നെയും ആപ്ലിക്കേഷൻ എങ്ങനെ സമാരംഭിക്കുന്നു എന്നതിനെയും ആശ്രയിച്ച്) ഉപയോഗിക്കാം.

ആദ്യം, ഒരു ആപ്ലിക്കേഷൻ പ്രവർത്തിപ്പിക്കുന്നതിനുള്ള ഏറ്റവും സാർവത്രിക ഓപ്ഷൻ നോക്കാം - ഒരു ഡോക്കർ കണ്ടെയ്നറിൽ. ഇത് ചെയ്യുന്നതിന്, ഞങ്ങൾ കീ ഉപയോഗിക്കും --docker-run കോഡ് ഉപയോഗിച്ച് ഡയറക്ടറി കണ്ടെയ്‌നറിലേക്ക് മൌണ്ട് ചെയ്യുക: -v `pwd`:/app

ഇത് പ്രൊജക്റ്റ് ഡയറക്‌ടറിയിൽ നിന്നാണ് പ്രവർത്തിക്കുന്നത് എന്ന് ദയവായി ശ്രദ്ധിക്കുക. ആപ്ലിക്കേഷൻ കോഡ് ഡയറക്ടറിയിൽ മൗണ്ട് ചെയ്യും /app ഒരു കണ്ടെയ്നറിൽ.

അടുത്തത്: -v /tmp/app/var/run/secrets:/var/run/secrets - സർട്ടിഫിക്കറ്റ്/ടോക്കൺ ഉള്ള ഡയറക്ടറി ഒരു കണ്ടെയ്‌നറിൽ മൌണ്ട് ചെയ്യാൻ.

ഈ ഓപ്‌ഷൻ ഒടുവിൽ ആപ്ലിക്കേഷൻ റൺ ചെയ്യുന്ന ചിത്രം പിന്തുടരുന്നു. NB: ഒരു ചിത്രം നിർമ്മിക്കുമ്പോൾ, നിങ്ങൾ വ്യക്തമാക്കണം CMD അഥവാ ENTRYPOINT!

അടുത്തതായി കൃത്യമായി എന്ത് സംഭവിക്കും?

• കുബെർനെറ്റസിൽ, നിർദ്ദിഷ്‌ട വിന്യാസത്തിനായി, പകർപ്പുകളുടെ എണ്ണം 0 ആയി മാറ്റും. പകരം, ഒരു പുതിയ വിന്യാസം ആരംഭിക്കും - പകരം ഒരു കണ്ടെയ്‌നർ backend.
• ഡെസ്‌ക്‌ടോപ്പിൽ 2 കണ്ടെയ്‌നറുകൾ സമാരംഭിക്കും: ആദ്യത്തേത് ടെലിപ്രെസെൻസിനൊപ്പം (ഇത് കുബർനെറ്റസിൽ നിന്നുള്ള അഭ്യർത്ഥനകൾ പ്രോക്‌സി ചെയ്യും), രണ്ടാമത്തേത് ആപ്ലിക്കേഷൻ വികസിപ്പിക്കുന്നതിനൊപ്പം.
• ഞങ്ങൾ ആപ്ലിക്കേഷൻ ഉപയോഗിച്ച് കണ്ടെയ്‌നറിലേക്ക് എക്‌സിക് ചെയ്യുകയാണെങ്കിൽ, വിന്യാസ സമയത്ത് ഹെൽം കൈമാറുന്ന എല്ലാ ENV വേരിയബിളുകളും ഞങ്ങൾക്ക് ലഭ്യമാകും, കൂടാതെ എല്ലാ സേവനങ്ങളും ലഭ്യമാകും. നിങ്ങളുടെ പ്രിയപ്പെട്ട IDE-യിൽ കോഡ് എഡിറ്റ് ചെയ്ത് ഫലം ആസ്വദിക്കുക മാത്രമാണ് അവശേഷിക്കുന്നത്.
• ജോലിയുടെ അവസാനം, നിങ്ങൾ ടെലിപ്രെസെൻസ് പ്രവർത്തിക്കുന്ന ടെർമിനൽ അടയ്ക്കേണ്ടതുണ്ട് (Ctrl + C ഉപയോഗിച്ച് സെഷൻ അവസാനിപ്പിക്കുക) - ഡോക്കർ കണ്ടെയ്നറുകൾ ഡെസ്ക്ടോപ്പിൽ നിർത്തും, കുബർനെറ്റസിൽ എല്ലാം അതിന്റെ പ്രാരംഭ നിലയിലേക്ക് മടങ്ങും. പ്രതിജ്ഞാബദ്ധത, എംആർ ഇഷ്യൂ ചെയ്യുക, അവലോകനം/ലയിപ്പിക്കുക/... (നിങ്ങളുടെ വർക്ക്ഫ്ലോകളെ ആശ്രയിച്ച്)

ഒരു ഡോക്കർ കണ്ടെയ്‌നറിൽ ആപ്ലിക്കേഷൻ റൺ ചെയ്യാൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നില്ലെങ്കിൽ - ഉദാഹരണത്തിന്, ഞങ്ങൾ PHP-യിൽ അല്ല, Go- യിൽ വികസിപ്പിക്കുന്നു, ഇപ്പോഴും അത് പ്രാദേശികമായി നിർമ്മിക്കുന്നു - ടെലിപ്രസെൻസ് സമാരംഭിക്കുന്നത് കൂടുതൽ ലളിതമായിരിക്കും:

telepresence --namespace {{ .Values.global.env }} --swap-deployment {{ .Chart.Name  }}:backend --mount=true

അപ്ലിക്കേഷൻ Kubernetes API ആക്‌സസ് ചെയ്യുകയാണെങ്കിൽ, നിങ്ങൾ കീ ഡയറക്‌ടറി (https://www.telepresence.io/howto/volumes) മൗണ്ട് ചെയ്യേണ്ടതുണ്ട്. ലിനക്സിനായി ഒരു യൂട്ടിലിറ്റി ഉണ്ട് പ്രൂട്ട്:

proot -b $TELEPRESENCE_ROOT/var/run/secrets/:/var/run/secrets bash

ഓപ്ഷൻ ഇല്ലാതെ ടെലിപ്രെസെൻസ് സമാരംഭിച്ചതിന് ശേഷം --docker-run എല്ലാ പരിസ്ഥിതി വേരിയബിളുകളും നിലവിലെ ടെർമിനലിൽ ലഭ്യമാകും, അതിനാൽ ആപ്ലിക്കേഷൻ അതിൽ ലോഞ്ച് ചെയ്യണം.

NB: ഉപയോഗിക്കുമ്പോൾ, ഉദാഹരണത്തിന്, PHP, വികസനത്തിനായി വിവിധ op_cache, apc, മറ്റ് ആക്സിലറേറ്ററുകൾ എന്നിവ പ്രവർത്തനരഹിതമാക്കാൻ നിങ്ങൾ ഓർക്കണം - അല്ലാത്തപക്ഷം കോഡ് എഡിറ്റുചെയ്യുന്നത് ആവശ്യമുള്ള ഫലത്തിലേക്ക് നയിക്കില്ല.

ഫലങ്ങൾ

ഈ പ്ലാറ്റ്‌ഫോമിന്റെ വ്യാപനത്തിന് ആനുപാതികമായി വളരുന്ന ഒരു പ്രശ്‌നമാണ് കുബർനെറ്റസുമായുള്ള പ്രാദേശിക വികസനം. ഡവലപ്പർമാരിൽ നിന്ന് (ഞങ്ങളുടെ ക്ലയന്റുകളിൽ നിന്ന്) പ്രസക്തമായ അഭ്യർത്ഥനകൾ സ്വീകരിച്ച്, ലഭ്യമായ ആദ്യ മാർഗങ്ങൾ ഉപയോഗിച്ച് ഞങ്ങൾ അവ പരിഹരിക്കാൻ തുടങ്ങി, എന്നിരുന്നാലും, ഇത് ദീർഘകാലത്തേക്ക് സ്വയം തെളിയിക്കപ്പെട്ടില്ല. ഭാഗ്യവശാൽ, ഇത് ഇപ്പോൾ മാത്രമല്ല, ഞങ്ങൾക്ക് മാത്രമല്ല വ്യക്തമാണ്, അതിനാൽ കൂടുതൽ അനുയോജ്യമായ മാർഗങ്ങൾ ഇതിനകം ലോകത്ത് പ്രത്യക്ഷപ്പെട്ടു, കൂടാതെ ടെലിപ്രസെൻസ് അവയിൽ ഏറ്റവും പ്രസിദ്ധമാണ് (വഴിയിൽ, ഉണ്ട് സ്കാർഫോൾഡ് Google-ൽ നിന്ന്). ഇത് ഉപയോഗിക്കുന്നതിനുള്ള ഞങ്ങളുടെ അനുഭവം ഇതുവരെ അത്ര മികച്ചതല്ല, പക്ഷേ ഇത് ഞങ്ങളുടെ “ഷോപ്പിലെ സഹപ്രവർത്തകർക്ക്” ശുപാർശ ചെയ്യാൻ ഇതിനകം കാരണം നൽകുന്നു - ഇത് പരീക്ഷിക്കുക!

പി.എസ്

K8s നുറുങ്ങുകളും തന്ത്രങ്ങളും പരമ്പരയിൽ നിന്നുള്ള മറ്റുള്ളവ:

• «Kubernetes നുറുങ്ങുകളും തന്ത്രങ്ങളും: NGINX പ്രവേശനത്തിലെ ഇഷ്‌ടാനുസൃത പിശക് പേജുകൾ";
• «ഒരു ക്ലസ്റ്ററിൽ പ്രവർത്തിക്കുന്ന ഉറവിടങ്ങൾ ഹെൽം 2 മാനേജ്മെന്റിന് കൈമാറുന്നു";
• «ഒരു വെബ് ആപ്ലിക്കേഷനിലെ നോഡ് അലോക്കേഷനെയും ലോഡുകളെയും കുറിച്ച്";
• «ഡെവലപ്പ് സൈറ്റുകളിലേക്കുള്ള ആക്സസ്";
• «വലിയ ഡാറ്റാബേസുകൾക്കായി ബൂട്ട്സ്ട്രാപ്പ് വേഗത്തിലാക്കുന്നു".

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