കുബർനെറ്റസിന്റെ അകത്തും പുറത്തും പ്രോജക്റ്റ് കോൺഫിഗറേഷൻ

ഞാൻ അടുത്തിടെ എഴുതി ഡോക്കറിലെ പ്രോജക്റ്റ് ലൈഫിനെയും അതിന് പുറത്തുള്ള ഡീബഗ്ഗിംഗ് കോഡിനെയും കുറിച്ചുള്ള ഉത്തരം, നിങ്ങൾക്ക് സ്വന്തമായി കോൺഫിഗറേഷൻ സിസ്റ്റം ഉണ്ടാക്കാൻ കഴിയുമെന്ന് അദ്ദേഹം സംക്ഷിപ്തമായി സൂചിപ്പിച്ചു, അതുവഴി കുബേറിൽ സേവനം നന്നായി പ്രവർത്തിക്കുകയും രഹസ്യങ്ങൾ കണ്ടെത്തുകയും ഡോക്കറിന് പുറത്ത് പോലും പ്രാദേശികമായി സൗകര്യപ്രദമായി പ്രവർത്തിക്കുകയും ചെയ്യുന്നു. സങ്കീർണ്ണമായ ഒന്നും തന്നെയില്ല, എന്നാൽ വിവരിച്ച "പാചകക്കുറിപ്പ്" ആർക്കെങ്കിലും ഉപകാരപ്പെട്ടേക്കാം :) കോഡ് പൈത്തണിലാണ്, പക്ഷേ ലോജിക് ഭാഷയുമായി ബന്ധിപ്പിച്ചിട്ടില്ല.

ചോദ്യത്തിന്റെ പശ്ചാത്തലം ഇതാണ്: ഒരു കാലത്ത് ഒരു പ്രോജക്റ്റ് ഉണ്ടായിരുന്നു, ആദ്യം അത് യൂട്ടിലിറ്റികളും സ്ക്രിപ്റ്റുകളും ഉള്ള ഒരു ചെറിയ മോണോലിത്ത് ആയിരുന്നു, എന്നാൽ കാലക്രമേണ അത് വളർന്നു, സേവനങ്ങളായി വിഭജിച്ചു, അത് മൈക്രോസർവീസുകളായി വിഭജിക്കാൻ തുടങ്ങി. പിന്നെ സ്കെയിൽ ചെയ്തു. ആദ്യം, ഇതെല്ലാം നഗ്നമായ വിപിഎസിലാണ് ചെയ്തത്, കോഡ് സജ്ജീകരിക്കുന്നതിനും വിന്യസിക്കുന്നതിനുമുള്ള പ്രക്രിയകൾ അൻസിബിൾ ഉപയോഗിച്ച് ഓട്ടോമേറ്റുചെയ്‌തു, കൂടാതെ ഓരോ സേവനവും ആവശ്യമായ ക്രമീകരണങ്ങളും കീകളും ഉപയോഗിച്ച് ഒരു YAML കോൺഫിഗറേഷൻ ഉപയോഗിച്ച് സമാഹരിച്ചു, കൂടാതെ സമാനമായ ഒരു കോൺഫിഗർ ഫയൽ ഉപയോഗിച്ചു. ലോക്കൽ ലോഞ്ചുകൾ, അത് വളരെ സൗകര്യപ്രദമായിരുന്നു, കാരണം .k ഈ കോൺഫിഗറേഷൻ ഒരു ആഗോള ഒബ്‌ജക്‌റ്റിലേക്ക് ലോഡ് ചെയ്‌തിരിക്കുന്നു, പ്രോജക്‌റ്റിൽ എവിടെ നിന്നും ആക്‌സസ് ചെയ്യാനാകും.

എന്നിരുന്നാലും, മൈക്രോസർവീസുകളുടെ എണ്ണം, അവയുടെ കണക്ഷനുകൾ, കൂടാതെ കേന്ദ്രീകൃത ലോഗിംഗും നിരീക്ഷണവും ആവശ്യമാണ്, കുബേരിലേക്കുള്ള ഒരു നീക്കത്തെ മുൻകൂട്ടി കാണിച്ചു, അത് ഇപ്പോഴും പുരോഗമിക്കുകയാണ്. സൂചിപ്പിച്ച പ്രശ്നങ്ങൾ പരിഹരിക്കുന്നതിനുള്ള സഹായത്തോടൊപ്പം, കുബെർനെറ്റസ് ഇൻഫ്രാസ്ട്രക്ചർ മാനേജ്മെന്റിനുള്ള അതിന്റെ സമീപനങ്ങൾ വാഗ്ദാനം ചെയ്യുന്നു. രഹസ്യങ്ങൾ എന്ന് വിളിക്കപ്പെടുന്നവ и അവരോടൊപ്പം പ്രവർത്തിക്കാനുള്ള വഴികൾ. മെക്കാനിസം സ്റ്റാൻഡേർഡും വിശ്വസനീയവുമാണ്, അതിനാൽ ഇത് ഉപയോഗിക്കാതിരിക്കുന്നത് അക്ഷരാർത്ഥത്തിൽ പാപമാണ്! എന്നാൽ അതേ സമയം, കോൺഫിഗറുമായി പ്രവർത്തിക്കുന്നതിന് എന്റെ നിലവിലെ ഫോർമാറ്റ് നിലനിർത്താൻ ഞാൻ ആഗ്രഹിക്കുന്നു: ഒന്നാമതായി, പ്രോജക്റ്റിന്റെ വിവിധ മൈക്രോസർവീസുകളിൽ ഇത് ഒരേപോലെ ഉപയോഗിക്കുന്നതിന്, രണ്ടാമതായി, ലളിതമായ ഒന്ന് ഉപയോഗിച്ച് ലോക്കൽ മെഷീനിൽ കോഡ് പ്രവർത്തിപ്പിക്കാൻ കഴിയും. കോൺഫിഗറേഷൻ ഫയൽ.

ഇക്കാര്യത്തിൽ, ഒരു കോൺഫിഗറേഷൻ ഒബ്‌ജക്‌റ്റ് നിർമ്മിക്കുന്നതിനുള്ള സംവിധാനം ഞങ്ങളുടെ ക്ലാസിക് കോൺഫിഗറേഷൻ ഫയലിലും കുബേറിൽ നിന്നുള്ള രഹസ്യങ്ങളിലും പ്രവർത്തിക്കാൻ കഴിയുന്ന തരത്തിൽ പരിഷ്‌ക്കരിച്ചു. മൂന്നാമത്തെ പൈത്തണിന്റെ ഭാഷയിൽ, കൂടുതൽ കർക്കശമായ കോൺഫിഗറേഷൻ ഘടനയും ഇനിപ്പറയുന്ന രീതിയിൽ വ്യക്തമാക്കിയിട്ടുണ്ട്:

ഡിക്റ്റ്[str, Dict[str, Union[str, int, float]]]

അതായത്, അന്തിമ കോഗ്ഫിഗ് എന്നത് പേരുള്ള വിഭാഗങ്ങളുള്ള ഒരു നിഘണ്ടുവാണ്, അവ ഓരോന്നും ലളിതമായ തരങ്ങളിൽ നിന്നുള്ള മൂല്യങ്ങളുള്ള ഒരു നിഘണ്ടുവാണ്. ഒരു പ്രത്യേക തരത്തിലുള്ള ഉറവിടങ്ങളിലേക്കുള്ള കോൺഫിഗറേഷനും പ്രവേശനവും വിഭാഗങ്ങൾ വിവരിക്കുന്നു. ഞങ്ങളുടെ കോൺഫിഗറേഷന്റെ ഒരു ഭാഗത്തിന്റെ ഉദാഹരണം:

adminka:
  django_secret: "ExtraLongAndHardCode"

db_main:
  engine: mysql
  host: 256.128.64.32
  user: cool_user
  password: "SuperHardPassword"

redis:
  host: 256.128.64.32
  pw: "SuperHardPassword"
  port: 26379

smtp:
  server: smtp.gmail.com
  port: 465
  email: [email protected]
  pw: "SuperHardPassword"

അതേ സമയം വയലും engine ഡാറ്റാബേസുകൾ SQLite-ൽ ഇൻസ്റ്റാൾ ചെയ്യാൻ കഴിയും, കൂടാതെ redis ക്രമീകരിക്കപ്പെട്ടതു mock, സംരക്ഷിക്കുന്നതിനുള്ള ഫയലിന്റെ പേരും വ്യക്തമാക്കുന്നു - ഈ പരാമീറ്ററുകൾ ശരിയായി തിരിച്ചറിയുകയും പ്രോസസ്സ് ചെയ്യുകയും ചെയ്യുന്നു, ഇത് ഡീബഗ്ഗിംഗ്, യൂണിറ്റ് ടെസ്റ്റിംഗ്, മറ്റ് ആവശ്യങ്ങൾ എന്നിവയ്ക്കായി പ്രാദേശികമായി കോഡ് പ്രവർത്തിപ്പിക്കുന്നത് എളുപ്പമാക്കുന്നു. മറ്റ് നിരവധി ആവശ്യങ്ങളുള്ളതിനാൽ ഇത് ഞങ്ങൾക്ക് വളരെ പ്രധാനമാണ് - ഞങ്ങളുടെ കോഡിന്റെ ഒരു ഭാഗം വിവിധ വിശകലന കണക്കുകൂട്ടലുകൾക്കായി ഉദ്ദേശിച്ചുള്ളതാണ്, ഇത് ഓർക്കസ്ട്രേഷനുള്ള സെർവറുകളിൽ മാത്രമല്ല, വിവിധ സ്ക്രിപ്റ്റുകളിലും പ്രവർത്തിക്കേണ്ട അനലിസ്റ്റുകളുടെ കമ്പ്യൂട്ടറുകളിലും പ്രവർത്തിക്കുന്നു. ബാക്കെൻഡ് പ്രശ്‌നങ്ങളെ ആശങ്കപ്പെടുത്താതെ സങ്കീർണ്ണമായ ഡാറ്റ പ്രോസസ്സിംഗ് പൈപ്പ്ലൈനുകൾ ഡീബഗ് ചെയ്യുക. വഴിയിൽ, കോൺഫിഗറേഷൻ ലേഔട്ട് കോഡ് ഉൾപ്പെടെയുള്ള ഞങ്ങളുടെ പ്രധാന ടൂളുകൾ ഇതിലൂടെയാണ് ഇൻസ്റ്റാൾ ചെയ്തിരിക്കുന്നതെന്ന് പങ്കിടുന്നത് ഉപദ്രവിക്കില്ല. setup.py - ഇത് ഒരുമിച്ച് പ്ലാറ്റ്‌ഫോമിൽ നിന്നും ഉപയോഗരീതിയിൽ നിന്നും സ്വതന്ത്രമായ ഒരൊറ്റ ആവാസവ്യവസ്ഥയായി ഞങ്ങളുടെ കോഡിനെ ഒന്നിപ്പിക്കുന്നു.

ഒരു കുബർനെറ്റസ് പോഡിന്റെ വിവരണം ഇതുപോലെ കാണപ്പെടുന്നു:

containers:
  - name : enter-api
    image: enter-api:latest
    ports:
      - containerPort: 80
    volumeMounts:
      - name: db-main-secret-volume
        mountPath: /etc/secrets/db-main

volumes:
  - name: db-main-secret-volume
    secret:
      secretName: db-main-secret

അതായത്, ഓരോ രഹസ്യവും ഓരോ വിഭാഗത്തെ വിവരിക്കുന്നു. രഹസ്യങ്ങൾ ഇതുപോലെയാണ് സൃഷ്ടിക്കപ്പെട്ടിരിക്കുന്നത്:

apiVersion: v1
kind: Secret
metadata:
  name: db-main-secret
type: Opaque
stringData:
  db_main.yaml: |
    engine: sqlite
    filename: main.sqlite3

ഇത് ഒരുമിച്ച് പാതയിൽ YAML ഫയലുകൾ സൃഷ്ടിക്കുന്നതിന് കാരണമാകുന്നു /etc/secrets/db-main/section_name.yaml

പ്രാദേശിക ലോഞ്ചുകൾക്കായി, പ്രോജക്റ്റിന്റെ റൂട്ട് ഡയറക്ടറിയിലോ എൻവയോൺമെന്റ് വേരിയബിളിൽ വ്യക്തമാക്കിയ പാതയിലോ സ്ഥിതി ചെയ്യുന്ന കോൺഫിഗറേഷൻ ഉപയോഗിക്കുന്നു. ഈ സൗകര്യങ്ങൾക്ക് ഉത്തരവാദിയായ കോഡ് സ്‌പോയിലറിൽ കാണാം.

config.py

__author__ = 'AivanF'
__copyright__ = 'Copyright 2020, AivanF'

import os
import yaml

__all__ = ['config']
PROJECT_DIR = os.path.abspath(__file__ + 3 * '/..')
SECRETS_DIR = '/etc/secrets'
KEY_LOG = '_config_log'
KEY_DBG = 'debug'

def is_yes(value):
    if isinstance(value, str):
        value = value.lower()
        if value in ('1', 'on', 'yes', 'true'):
            return True
    else:
        if value in (1, True):
            return True
    return False

def update_config_part(config, key, data):
    if key not in config:
        config[key] = data
    else:
        config[key].update(data)

def parse_big_config(config, filename):
    '''
    Parse YAML config with multiple section
    '''
    if not os.path.isfile(filename):
        return False
    with open(filename) as f:
        config_new = yaml.safe_load(f.read())
        for key, data in config_new.items():
            update_config_part(config, key, data)
        config[KEY_LOG].append(filename)
        return True

def parse_tiny_config(config, key, filename):
    '''
    Parse YAML config with a single section
    '''
    with open(filename) as f:
        config_tiny = yaml.safe_load(f.read())
        update_config_part(config, key, config_tiny)
        config[KEY_LOG].append(filename)

def combine_config():
    config = {
        # To debug config load code
        KEY_LOG: [],
        # To debug other code
        KEY_DBG: is_yes(os.environ.get('DEBUG')),
    }
    # For simple local runs
    CONFIG_SIMPLE = os.path.join(PROJECT_DIR, 'config.yaml')
    parse_big_config(config, CONFIG_SIMPLE)
    # For container's tests
    CONFIG_ENVVAR = os.environ.get('CONFIG')
    if CONFIG_ENVVAR is not None:
        if not parse_big_config(config, CONFIG_ENVVAR):
            raise ValueError(
                f'No config file from EnvVar:n'
                f'{CONFIG_ENVVAR}'
            )
    # For K8s secrets
    for path, dirs, files in os.walk(SECRETS_DIR):
        depth = path[len(SECRETS_DIR):].count(os.sep)
        if depth > 1:
            continue
        for file in files:
            if file.endswith('.yaml'):
                filename = os.path.join(path, file)
                key = file.rsplit('.', 1)[0]
                parse_tiny_config(config, key, filename)
    return config

def build_config():
    config = combine_config()
    # Preprocess
    for key, data in config.items():
        if key.startswith('db_'):
            if data['engine'] == 'sqlite':
                data['filename'] = os.path.join(PROJECT_DIR, data['filename'])
    # To verify correctness
    if config[KEY_DBG]:
        print(f'** Loaded config:n{yaml.dump(config)}')
    else:
        print(f'** Loaded config from: {config[KEY_LOG]}')
    return config

config = build_config()

ഇവിടെ യുക്തി വളരെ ലളിതമാണ്: പ്രോജക്റ്റ് ഡയറക്ടറിയിൽ നിന്നുള്ള വലിയ കോൺഫിഗേഷനുകളും എൻവയോൺമെന്റ് വേരിയബിൾ വഴിയുള്ള പാതകളും, കുബർ രഹസ്യങ്ങളിൽ നിന്നുള്ള ചെറിയ കോൺഫിഗറേഷൻ വിഭാഗങ്ങളും ഞങ്ങൾ സംയോജിപ്പിക്കുന്നു, തുടർന്ന് അവ അൽപ്പം മുൻകൂട്ടി പ്രോസസ്സ് ചെയ്യുന്നു. കൂടാതെ ചില വേരിയബിളുകൾ. രഹസ്യങ്ങളിൽ നിന്ന് ഫയലുകൾക്കായി തിരയുമ്പോൾ, ഒരു ഡെപ്ത് പരിമിതി ഉപയോഗിക്കുന്നുവെന്ന് ഞാൻ ശ്രദ്ധിക്കുന്നു, കാരണം രഹസ്യങ്ങൾ സ്വയം സംഭരിച്ചിരിക്കുന്ന ഓരോ രഹസ്യത്തിലും K8s ഒരു മറഞ്ഞിരിക്കുന്ന ഫോൾഡർ സൃഷ്ടിക്കുന്നു, കൂടാതെ ഒരു ലിങ്ക് ഉയർന്ന തലത്തിൽ സ്ഥിതിചെയ്യുന്നു.

വിവരിച്ചിരിക്കുന്നത് ആർക്കെങ്കിലും ഉപകാരപ്പെടുമെന്ന് ഞാൻ പ്രതീക്ഷിക്കുന്നു :) സുരക്ഷയെ കുറിച്ചോ മറ്റ് മെച്ചപ്പെടുത്തലിനുള്ള മറ്റ് മേഖലകളെ കുറിച്ചോ ഉള്ള അഭിപ്രായങ്ങളും ശുപാർശകളും സ്വീകരിക്കുന്നു. കമ്മ്യൂണിറ്റിയുടെ അഭിപ്രായവും രസകരമാണ്, കോൺഫിഗ്മാപ്‌സിന് (ഞങ്ങളുടെ പ്രോജക്റ്റ് ഇതുവരെ അവ ഉപയോഗിക്കുന്നില്ല) പിന്തുണ ചേർത്ത് GitHub / PyPI-യിൽ കോഡ് പ്രസിദ്ധീകരിക്കുന്നത് മൂല്യവത്താണോ? വ്യക്തിപരമായി, അത്തരം കാര്യങ്ങൾ പ്രോജക്റ്റുകൾക്ക് സാർവത്രികമാകാൻ കഴിയാത്തവിധം വ്യക്തിഗതമാണെന്ന് ഞാൻ കരുതുന്നു, കൂടാതെ ഇവിടെ നൽകിയിരിക്കുന്നത് പോലെ മറ്റുള്ളവരുടെ നിർവ്വഹണങ്ങളിലേക്ക് അൽപ്പം നോക്കുക, കൂടാതെ സൂക്ഷ്മതകൾ, നുറുങ്ങുകൾ, മികച്ച സമ്പ്രദായങ്ങൾ എന്നിവയെക്കുറിച്ചുള്ള ഒരു ചർച്ച, അഭിപ്രായങ്ങളിൽ കാണാൻ ഞാൻ പ്രതീക്ഷിക്കുന്നു. , മതി 😉

രജിസ്റ്റർ ചെയ്ത ഉപയോക്താക്കൾക്ക് മാത്രമേ സർവേയിൽ പങ്കെടുക്കാൻ കഴിയൂ. സൈൻ ഇൻദയവായി.

ഞാൻ ഒരു പ്രോജക്റ്റ്/ലൈബ്രറി ആയി പ്രസിദ്ധീകരിക്കണോ?

• 0,0%അതെ, ഞാൻ /contribution0 ഉപയോഗിക്കും

• 33,3%അതെ, അത് മികച്ചതായി തോന്നുന്നു4

• 41,7%ഇല്ല, ആരാണ് അത് അവരുടെ സ്വന്തം ഫോർമാറ്റിൽ അവരുടെ ആവശ്യങ്ങൾക്ക് അനുയോജ്യമാക്കേണ്ടത്5

• 25,0%ഞാൻ ഉത്തരം പറയുന്നതിൽ നിന്ന് വിട്ടുനിൽക്കും3

12 ഉപയോക്താക്കൾ വോട്ട് ചെയ്തു. 3 ഉപയോക്താക്കൾ വിട്ടുനിന്നു.

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