Ego nuper scripsi ubi breviter commemoravit tuam conformationem facere posse ut ministerium in Kuber bene operaretur, secreta evellere ac commode localiter etiam extra Docker excurrere. Nihil complicatum, sed describit "recipe" alicui utilem esse potest :) Codex in Pythone est, logica autem lingua non ligatur.
Ambitus quaestionis haec est: olim consilium unum fuit, primo monolitum parvum cum utilitatibus et scriptis, sed tempore crevit, in officia divisa, quae vicissim in micro servitia dividi coepta sunt; deinde obsignata sunt. In primis, omnia nuda VPS gesta sunt, processus constituendi et explicandi codicem in quo usus Ansible automati erant, et unumquodque officium cum YAML config uncinis et clavibus necessariis exaratum est, et similis fasciculi config adhibebantur. immissae locales, quae valde commodae erant, quia .k haec config in obiecto globali onusta est, ubique in incepto pervia est.
Attamen incrementum in numero microservices, nexus, et adumbravit se movere ad Kuber, quod in cursu est. Una cum auxilio ad praedictas difficultates solvendas Kubernetes aditus praebet ad administrationem infrastructuram, comprehendo ΠΈ . Mechanismus vexillum est et certum, quare proprie peccatum est eo non uti! Sed simul, velim ponere formam meam currentem ad operandum cum config: uno modo, ea uti uniformiter in diversis rei minimis servitiis, et deinde, ut codicem in machina locali uno simplici utente currere possit. file aboutconfig.
Hac de re, mechanismus ad obiectum configurationis construendum mutatum est ut tum cum lima config cinematographico nostro tum cum secretis ab Kuber elaborare posse. Rigidiorem config structuram etiam nominatam in lingua Pythonis tertii, hoc modo;
Dict[str, Dict[str, Union[str, int, float]]]
Id est, finalis cogfig est dictionarium cum sectionibus nominatis, quorum unumquodque dictionarium cum valoribus simplicium generum est. Et sectiones figuram et accessum facultatum cuiusdam generis describunt. Exemplum in nostro nummo config;
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"Eodem tempore agri engine databases in SQLite institui possunt, et redis set ad mockdenotans etiam nomen tabellae ad salvandum - hi parametri recte agnoscuntur et discursum sunt, quod facile efficit ut codicem localiter ad debugging, unitatem probationis et quaslibet necessitates transmittat. Hoc maxime interest nobis quod multae aliae necessitates - pars nostri codicis destinatur pro variis analyticis calculis, non solum in ministris cum orchestratione, sed etiam in variis scriptoribus, ac in analystarum computatoribus, qui per operare opus est. et debug implicata notitia processus pipelines sine sollicitudine backend quaestiones. Obiter communicare non nocebit quod instrumenta nostra principalia, inclusa in calculis config, via inaugurata sunt. setup.py β haec unum codicem nostrum coniungit in unam oecosystematis, independentem a suggestu ac methodo usus.
Descriptio vasculi Kubernetes hoc modo spectat:
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-secretHoc est, unumquodque arcanum describit unam sectionem. Ipsa occulta creantur sic:
apiVersion: v1
kind: Secret
metadata:
name: db-main-secret
type: Opaque
stringData:
db_main.yaml: |
engine: sqlite
filename: main.sqlite3Simul hoc consequitur in creatione YAML imaginum per viam /etc/secrets/db-main/section_name.yaml
Et ad launches locales, config adhibetur, in radice indicis propositi vel secundum viam quae in ambitu variabili definitum est. In codice author harum commodorum vastator videri potest.
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()Logica hic plane simplex est: magnas configiones iungimus ex presul et semitas in ambitu variabili, et parvas sectiones de Kuber secretis config, et deinde eas paulo praepro. Pluribus variabilibus. Animadverto quod cum ex arcanis scriniis quaerendo, profunditas limitatio adhibetur, quia K8s occultam folder in unoquoque occulto creat, ubi ipsa secreta reponuntur, et sicut nexus in altiori gradu collocatur.
Spero quod descriptum erit alicui usui esse :) Quaevis commentaria et commendationes circa securitatem vel in aliis locis ad emendationem acceptantur. Opinatio communitatis etiam interesting, fortasse pro ConfigMaps additamento digna (projectio nostro adhuc non utitur) et codicem de GitHub / PyPI evulgans? Ipse tamen existimo talia nimis singula esse ut incepta universalia sint, et parum despectus ad aliorum exsecutiones hominum, sicut hic ponitur, et disceptatio de nuanciis, apicibus et exercitiis optimis, quas in commentationibus videre spero. Satis est
Tantum usores descripserunt in aliquet participare possunt. Te gratissimum esse.
Egone ut project/library publish?
-
0,0%Ita, uti / contribution0
-
33,3%Ita, quod sonat great4
-
41,7%Imo, qui id ipsum facere debet in sua forma et ad suas necessitates congruere
-
25,0%Ego parcam answering3
12 utentes censuerunt. 3 utentes abstinuerunt.
Source: www.habr.com