Kubernetes-ലേക്ക് ഒരു ആപ്ലിക്കേഷൻ മൈഗ്രേറ്റ് ചെയ്യുമ്പോൾ പ്രാദേശിക ഫയലുകൾ

Kubernetes ഉപയോഗിച്ച് ഒരു CI/CD പ്രോസസ്സ് നിർമ്മിക്കുമ്പോൾ, പുതിയ ഇൻഫ്രാസ്ട്രക്ചറിൻ്റെ ആവശ്യകതകളും അതിലേക്ക് കൈമാറ്റം ചെയ്യപ്പെടുന്ന ആപ്ലിക്കേഷനും തമ്മിലുള്ള പൊരുത്തക്കേടിൻ്റെ പ്രശ്നം ചിലപ്പോൾ ഉയർന്നുവരുന്നു. പ്രത്യേകിച്ചും, ആപ്ലിക്കേഷൻ ബിൽഡ് ഘട്ടത്തിൽ അത് നേടേണ്ടത് പ്രധാനമാണ് один ഉപയോഗിക്കുന്ന ചിത്രം всех പ്രോജക്റ്റ് പരിസരങ്ങളും ക്ലസ്റ്ററുകളും. ഈ തത്വം ശരിയായതിന് അടിവരയിടുന്നു Google പ്രകാരം കണ്ടെയ്നർ മാനേജ്മെൻ്റ് (ഇതിനെക്കുറിച്ച് ഒന്നിലധികം തവണ സംസാരിച്ചു ഞങ്ങളുടെ സാങ്കേതിക വകുപ്പും).

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

ഒരു ക്ലസ്റ്റർ പ്രവർത്തിപ്പിക്കുമ്പോൾ അസുഖകരമായ പ്രത്യാഘാതങ്ങൾക്ക് ഇടയാക്കുന്ന ഫയലുകൾ സംഭരിക്കുന്നതിനുള്ള ജനപ്രിയ പരിഹാര പരിഹാരങ്ങൾ നോക്കാം, കൂടാതെ കൂടുതൽ ശരിയായ പാത ചൂണ്ടിക്കാണിക്കുക.

സ്റ്റാറ്റിക് സ്റ്റോറേജ്

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

• webroot/assets/2072c2df/css/…
• webroot/assets/2072c2df/images/…
• webroot/assets/2072c2df/js/…

ഒരു ക്ലസ്റ്ററിൻ്റെ അടിസ്ഥാനത്തിൽ ഇത് എന്താണ് അർത്ഥമാക്കുന്നത്?

ഏറ്റവും ലളിതമായ ഉദാഹരണം

സ്റ്റാറ്റിക് ഡാറ്റ വിതരണം ചെയ്യുന്നതിനും ലളിതമായ അഭ്യർത്ഥനകൾ പ്രോസസ്സ് ചെയ്യുന്നതിനും PHP ന് മുമ്പായി nginx വരുമ്പോൾ നമുക്ക് വളരെ സാധാരണമായ ഒരു കേസ് എടുക്കാം. ഏറ്റവും എളുപ്പമുള്ള വഴി - വിന്യാസ രണ്ട് പാത്രങ്ങളോടൊപ്പം:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: site
spec:
  selector:
    matchLabels:
      component: backend
  template:
    metadata:
      labels:
        component: backend
    spec:
      volumes:
        - name: nginx-config
          configMap:
            name: nginx-configmap
      containers:
      - name: php
        image: own-image-with-php-backend:v1.0
        command: ["/usr/local/sbin/php-fpm","-F"]
        workingDir: /var/www
      - name: nginx
        image: nginx:1.16.0
        command: ["/usr/sbin/nginx", "-g", "daemon off;"]
        volumeMounts:
        - name: nginx-config
          mountPath: /etc/nginx/conf.d/default.conf
          subPath: nginx.conf

ഒരു ലളിതമായ രൂപത്തിൽ, nginx കോൺഫിഗറേഷൻ ഇനിപ്പറയുന്നതിലേക്ക് ചുരുങ്ങുന്നു:

apiVersion: v1
kind: ConfigMap
metadata:
  name: "nginx-configmap"
data:
  nginx.conf: |
    server {
        listen 80;
        server_name _;
        charset utf-8;
        root  /var/www;

        access_log /dev/stdout;
        error_log /dev/stderr;

        location / {
            index index.php;
            try_files $uri $uri/ /index.php?$args;
        }

        location ~ .php$ {
            fastcgi_pass 127.0.0.1:9000;
            fastcgi_index index.php;
            include fastcgi_params;
        }
    }

നിങ്ങൾ ആദ്യം സൈറ്റ് ആക്സസ് ചെയ്യുമ്പോൾ, അസറ്റുകൾ PHP കണ്ടെയ്നറിൽ ദൃശ്യമാകും. എന്നാൽ ഒരു പോഡിനുള്ളിലെ രണ്ട് കണ്ടെയ്‌നറുകളുടെ കാര്യത്തിൽ, ഈ സ്റ്റാറ്റിക് ഫയലുകളെക്കുറിച്ച് nginx-ന് ഒന്നും അറിയില്ല, അവ (കോൺഫിഗറേഷൻ അനുസരിച്ച്) അവയ്ക്ക് നൽകണം. തൽഫലമായി, CSS, JS ഫയലുകളിലേക്കുള്ള എല്ലാ അഭ്യർത്ഥനകൾക്കും ക്ലയൻ്റ് 404 പിശക് കാണും. ഇവിടെ ഏറ്റവും ലളിതമായ പരിഹാരം കണ്ടെയ്നറുകൾക്കായി ഒരു പൊതു ഡയറക്ടറി സംഘടിപ്പിക്കുക എന്നതാണ്. പ്രാകൃത ഓപ്ഷൻ - പൊതുവായത് emptyDir:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: site
spec:
  selector:
    matchLabels:
      component: backend
  template:
    metadata:
      labels:
        component: backend
    spec:
      volumes:
        - name: assets
          emptyDir: {}
        - name: nginx-config
          configMap:
            name: nginx-configmap
      containers:
      - name: php
        image: own-image-with-php-backend:v1.0
        command: ["/usr/local/sbin/php-fpm","-F"]
        workingDir: /var/www
        volumeMounts:
        - name: assets
          mountPath: /var/www/assets
      - name: nginx
        image: nginx:1.16.0
        command: ["/usr/sbin/nginx", "-g", "daemon off;"]
        volumeMounts:
        - name: assets
          mountPath: /var/www/assets
        - name: nginx-config
          mountPath: /etc/nginx/conf.d/default.conf
          subPath: nginx.conf

ഇപ്പോൾ കണ്ടെയ്‌നറിൽ ജനറേറ്റുചെയ്‌ത സ്റ്റാറ്റിക് ഫയലുകൾ nginx ശരിയായി നൽകുന്നു. എന്നാൽ ഇത് ഒരു പ്രാകൃത പരിഹാരമാണെന്ന് ഞാൻ നിങ്ങളെ ഓർമ്മിപ്പിക്കട്ടെ, അതിനർത്ഥം ഇത് ആദർശത്തിൽ നിന്ന് വളരെ അകലെയാണെന്നും അതിൻ്റേതായ സൂക്ഷ്മതകളും പോരായ്മകളും ഉണ്ട്, അവ ചുവടെ ചർച്ചചെയ്യുന്നു.

കൂടുതൽ വിപുലമായ സംഭരണം

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

കൂടാതെ, കൂടുതലോ കുറവോ ലോഡ് ചെയ്ത പ്രോജക്റ്റ് ഞങ്ങളുടെ പക്കലുണ്ടാകാം, അതിനർത്ഥം ആപ്ലിക്കേഷൻ്റെ ഒരു പകർപ്പ് മതിയാകില്ല എന്നാണ്:

• നമുക്ക് അത് സ്കെയിൽ ചെയ്യാം വിന്യാസ രണ്ട് പകർപ്പുകൾ വരെ.
• സൈറ്റ് ആദ്യമായി ആക്‌സസ് ചെയ്‌തപ്പോൾ, അസറ്റുകൾ ഒരു പകർപ്പിൽ സൃഷ്‌ടിച്ചു.
• ചില ഘട്ടങ്ങളിൽ, രണ്ടാമത്തെ പകർപ്പിലേക്ക് ഒരു അഭ്യർത്ഥന അയയ്‌ക്കാൻ ഇൻഗ്രസ് തീരുമാനിച്ചു (ലോഡ് ബാലൻസിംഗ് ആവശ്യങ്ങൾക്കായി), ഈ അസറ്റുകൾ ഇതുവരെ ഉണ്ടായിരുന്നില്ല. അല്ലെങ്കിൽ നമ്മൾ ഉപയോഗിക്കുന്നതിനാൽ അവ ഇനി ഉണ്ടാകില്ല RollingUpdate ഇപ്പോൾ ഞങ്ങൾ വിന്യാസം നടത്തുകയാണ്.

പൊതുവേ, ഫലം വീണ്ടും തെറ്റുകൾ ആണ്.

പഴയ ആസ്തികൾ നഷ്ടപ്പെടാതിരിക്കാൻ, നിങ്ങൾക്ക് മാറ്റാവുന്നതാണ് emptyDir ഓൺ hostPath, ഒരു ക്ലസ്റ്റർ നോഡിലേക്ക് സ്റ്റാറ്റിക് ഫിസിക്കൽ ചേർക്കുന്നു. ഈ സമീപനം മോശമാണ്, കാരണം നമ്മൾ യഥാർത്ഥത്തിൽ ചെയ്യേണ്ടതുണ്ട് ഒരു പ്രത്യേക ക്ലസ്റ്റർ നോഡിലേക്ക് ബന്ധിപ്പിക്കുക നിങ്ങളുടെ ആപ്ലിക്കേഷൻ, കാരണം - മറ്റ് നോഡുകളിലേക്ക് നീങ്ങുന്ന സാഹചര്യത്തിൽ - ഡയറക്ടറിയിൽ ആവശ്യമായ ഫയലുകൾ അടങ്ങിയിരിക്കില്ല. അല്ലെങ്കിൽ നോഡുകൾക്കിടയിൽ ഏതെങ്കിലും തരത്തിലുള്ള പശ്ചാത്തല ഡയറക്ടറി സിൻക്രൊണൈസേഷൻ ആവശ്യമാണ്.

എന്താണ് പരിഹാരങ്ങൾ?

1. ഹാർഡ്‌വെയറും ഉറവിടങ്ങളും അനുവദിക്കുകയാണെങ്കിൽ, നിങ്ങൾക്ക് ഉപയോഗിക്കാം cephfs സ്റ്റാറ്റിക് ആവശ്യങ്ങൾക്ക് തുല്യമായി ആക്സസ് ചെയ്യാവുന്ന ഒരു ഡയറക്ടറി സംഘടിപ്പിക്കുന്നതിന്. ഔദ്യോഗിക ഡോക്യുമെന്റേഷൻ SSD ഡ്രൈവുകൾ, കുറഞ്ഞത് മൂന്ന് മടങ്ങ് പകർപ്പുകൾ, ക്ലസ്റ്റർ നോഡുകൾക്കിടയിൽ സ്ഥിരതയുള്ള "കട്ടിയുള്ള" കണക്ഷൻ എന്നിവ ശുപാർശ ചെയ്യുന്നു.
2. ഒരു NFS സെർവർ ഓർഗനൈസുചെയ്യുക എന്നതാണ് കുറഞ്ഞ ഡിമാൻഡ് ഓപ്ഷൻ. എന്നിരുന്നാലും, വെബ് സെർവർ അഭ്യർത്ഥനകൾ പ്രോസസ്സ് ചെയ്യുന്നതിനുള്ള പ്രതികരണ സമയത്തിൽ സാധ്യമായ വർദ്ധനവ് നിങ്ങൾ കണക്കിലെടുക്കേണ്ടതുണ്ട്, കൂടാതെ തെറ്റ് സഹിഷ്ണുത ആഗ്രഹിക്കുന്നത് വളരെയേറെ അവശേഷിക്കും. പരാജയത്തിൻ്റെ അനന്തരഫലങ്ങൾ വിനാശകരമാണ്: മൌണ്ട് നഷ്ടം ആകാശത്തേക്ക് കുതിച്ചുകയറുന്ന LA ലോഡിൻ്റെ സമ്മർദ്ദത്തിൽ ക്ലസ്റ്ററിനെ മരണത്തിലേക്ക് നയിക്കുന്നു.

മറ്റ് കാര്യങ്ങളിൽ, സ്ഥിരമായ സംഭരണം സൃഷ്ടിക്കുന്നതിനുള്ള എല്ലാ ഓപ്ഷനുകളും ആവശ്യമാണ് പശ്ചാത്തല വൃത്തിയാക്കൽ ഒരു നിശ്ചിത കാലയളവിൽ ശേഖരിച്ച ഫയലുകളുടെ കാലഹരണപ്പെട്ട സെറ്റുകൾ. PHP ഉള്ള കണ്ടെയ്നറുകൾക്ക് മുന്നിൽ നിങ്ങൾക്ക് ഇടാം ഡെമൺസെറ്റ് കാഷിംഗ് nginx-ൽ നിന്ന്, ഇത് അസറ്റുകളുടെ പകർപ്പുകൾ പരിമിത കാലത്തേക്ക് സംഭരിക്കും. ഈ സ്വഭാവം ഉപയോഗിച്ച് എളുപ്പത്തിൽ ക്രമീകരിക്കാവുന്നതാണ് proxy_cache ദിവസങ്ങളിൽ സ്റ്റോറേജ് ഡെപ്ത് അല്ലെങ്കിൽ ഡിസ്ക് സ്പേസിൻ്റെ ജിഗാബൈറ്റ്.

മുകളിൽ സൂചിപ്പിച്ച, വിതരണം ചെയ്ത ഫയൽ സിസ്റ്റങ്ങളുമായി ഈ രീതി സംയോജിപ്പിക്കുന്നത് ഭാവനയ്ക്ക് ഒരു വലിയ ഫീൽഡ് നൽകുന്നു, ഇത് നടപ്പിലാക്കുകയും പിന്തുണയ്ക്കുകയും ചെയ്യുന്നവരുടെ ബജറ്റും സാങ്കേതിക സാധ്യതകളും മാത്രം പരിമിതപ്പെടുത്തിയിരിക്കുന്നു. അനുഭവത്തിൽ നിന്ന്, സിസ്റ്റം ലളിതമാണ്, അത് കൂടുതൽ സ്ഥിരതയുള്ളതാണെന്ന് നമുക്ക് പറയാൻ കഴിയും. അത്തരം പാളികൾ ചേർക്കുമ്പോൾ, ഇൻഫ്രാസ്ട്രക്ചർ പരിപാലിക്കുന്നത് വളരെ ബുദ്ധിമുട്ടാണ്, അതേ സമയം ഏതെങ്കിലും പരാജയങ്ങൾ കണ്ടെത്തുന്നതിനും വീണ്ടെടുക്കുന്നതിനും ചെലവഴിക്കുന്ന സമയം വർദ്ധിക്കുന്നു.

ശുപാർശ

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

Yii ചട്ടക്കൂട് ഉപയോഗിച്ച് ഞങ്ങൾ നിർദ്ദിഷ്ട ഉദാഹരണത്തിലേക്ക് മടങ്ങുകയും അതിൻ്റെ ഘടന പരിശോധിക്കാതിരിക്കുകയും ചെയ്താൽ (ഇത് ലേഖനത്തിൻ്റെ ഉദ്ദേശ്യമല്ല), രണ്ട് ജനപ്രിയ സമീപനങ്ങൾ ചൂണ്ടിക്കാണിച്ചാൽ മതി:

1. പ്രവചനാതീതമായ സ്ഥലത്ത് അസറ്റുകൾ സ്ഥാപിക്കുന്നതിന് ഇമേജ് ബിൽഡ് പ്രോസസ്സ് മാറ്റുക. ഇതുപോലുള്ള വിപുലീകരണങ്ങളിൽ ഇത് നിർദ്ദേശിക്കപ്പെട്ടിരിക്കുന്നു/നടപ്പാക്കുന്നു yii2-സ്റ്റാറ്റിക്-അസറ്റുകൾ.
2. അസറ്റ് ഡയറക്‌ടറികൾക്കായി പ്രത്യേക ഹാഷുകൾ നിർവചിക്കുക, ഉദാ. ഈ അവതരണം (സ്ലൈഡ് നമ്പർ 35 മുതൽ ആരംഭിക്കുന്നു). വഴിയിൽ, റിപ്പോർട്ടിൻ്റെ രചയിതാവ് ആത്യന്തികമായി (കാരണമില്ലാതെയല്ല!) ബിൽഡ് സെർവറിൽ അസറ്റുകൾ കൂട്ടിച്ചേർത്തതിന് ശേഷം, അവ ഒരു സെൻട്രൽ സ്റ്റോറേജിലേക്ക് (S3 പോലെ) അപ്‌ലോഡ് ചെയ്യാൻ ഉപദേശിക്കുന്നു, അതിന് മുന്നിൽ ഒരു CDN സ്ഥാപിക്കുക.

ഡൗൺലോഡ് ചെയ്യാവുന്ന ഫയലുകൾ

ഒരു കുബെർനെറ്റസ് ക്ലസ്റ്ററിലേക്ക് ഒരു ആപ്ലിക്കേഷൻ മൈഗ്രേറ്റ് ചെയ്യുമ്പോൾ തീർച്ചയായും പ്രവർത്തനത്തിൽ വരുന്ന മറ്റൊരു കാര്യം ഫയൽ സിസ്റ്റത്തിൽ ഉപയോക്തൃ ഫയലുകൾ സംഭരിക്കുക എന്നതാണ്. ഉദാഹരണത്തിന്, ഞങ്ങൾക്ക് വീണ്ടും ഒരു PHP ആപ്ലിക്കേഷൻ ഉണ്ട്, അത് ഒരു അപ്‌ലോഡ് ഫോമിലൂടെ ഫയലുകൾ സ്വീകരിക്കുകയും പ്രവർത്തന സമയത്ത് അവ ഉപയോഗിച്ച് എന്തെങ്കിലും ചെയ്യുകയും തിരികെ അയയ്ക്കുകയും ചെയ്യുന്നു.

കുബർനെറ്റസിൽ, ഈ ഫയലുകൾ സ്ഥാപിക്കേണ്ട സ്ഥലം ആപ്ലിക്കേഷൻ്റെ എല്ലാ പകർപ്പുകൾക്കും പൊതുവായിരിക്കണം. ആപ്ലിക്കേഷൻ്റെ സങ്കീർണ്ണതയെയും ഈ ഫയലുകളുടെ സ്ഥിരത ഓർഗനൈസുചെയ്യേണ്ടതിൻ്റെ ആവശ്യകതയെയും ആശ്രയിച്ച്, മുകളിൽ സൂചിപ്പിച്ച പങ്കിട്ട ഉപകരണ ഓപ്ഷനുകൾ അത്തരമൊരു സ്ഥലമായിരിക്കാം, പക്ഷേ, നമ്മൾ കാണുന്നതുപോലെ, അവയ്ക്ക് അവയുടെ പോരായ്മകളുണ്ട്.

ശുപാർശ

ഒരു പരിഹാരമാണ് S3-അനുയോജ്യമായ സംഭരണം ഉപയോഗിക്കുന്നു (ഇത് മിനിയോ പോലെയുള്ള ഏതെങ്കിലും തരത്തിലുള്ള സ്വയം ഹോസ്റ്റ് ചെയ്ത വിഭാഗമാണെങ്കിൽ പോലും). S3-ലേക്ക് മാറുന്നതിന് മാറ്റങ്ങൾ ആവശ്യമായി വരും കോഡ് തലത്തിൽ, മുൻവശത്ത് ഉള്ളടക്കം എങ്ങനെ വിതരണം ചെയ്യും, ഞങ്ങൾക്ക് ഇതിനകം ഉണ്ട് എഴുതി.

ഉപയോക്തൃ സെഷനുകൾ

വെവ്വേറെ, ഉപയോക്തൃ സെഷനുകളുടെ സംഭരണത്തിൻ്റെ ഓർഗനൈസേഷൻ ശ്രദ്ധിക്കേണ്ടതാണ്. പലപ്പോഴും ഇവയും ഡിസ്കിലെ ഫയലുകളാണ്, കുബെർനെറ്റസിൻ്റെ പശ്ചാത്തലത്തിൽ ഉപയോക്താവിൻ്റെ അഭ്യർത്ഥന മറ്റൊരു കണ്ടെയ്‌നറിൽ അവസാനിച്ചാൽ അതിൽ നിന്ന് സ്ഥിരമായ അംഗീകാര അഭ്യർത്ഥനകളിലേക്ക് നയിക്കും.

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

apiVersion: networking.k8s.io/v1beta1
kind: Ingress
metadata:
  name: nginx-test
  annotations:
    nginx.ingress.kubernetes.io/affinity: "cookie"
    nginx.ingress.kubernetes.io/session-cookie-name: "route"
    nginx.ingress.kubernetes.io/session-cookie-expires: "172800"
    nginx.ingress.kubernetes.io/session-cookie-max-age: "172800"

spec:
  rules:
  - host: stickyingress.example.com
    http:
      paths:
      - backend:
          serviceName: http-svc
          servicePort: 80
        path: /

എന്നാൽ ഇത് ആവർത്തിച്ചുള്ള വിന്യാസത്തിലെ പ്രശ്നങ്ങൾ ഇല്ലാതാക്കില്ല.

ശുപാർശ

അപേക്ഷ കൈമാറുക എന്നതാണ് കൂടുതൽ ശരിയായ മാർഗം memcached, Redis എന്നിവയിലും സമാനമായ പരിഹാരങ്ങളിലും സെഷനുകൾ സംഭരിക്കുന്നു - പൊതുവേ, ഫയൽ ഓപ്ഷനുകൾ പൂർണ്ണമായും ഉപേക്ഷിക്കുക.

തീരുമാനം

ടെക്‌സ്‌റ്റിൽ ചർച്ച ചെയ്‌തിരിക്കുന്ന ഇൻഫ്രാസ്ട്രക്ചർ സൊല്യൂഷനുകൾ താൽക്കാലിക “ക്രച്ചസ്” ഫോർമാറ്റിൽ മാത്രമേ ഉപയോഗിക്കാൻ യോഗ്യമാണ് (ഇത് ഇംഗ്ലീഷിൽ പരിഹാരമായി കൂടുതൽ മനോഹരമായി തോന്നുന്നു). കുബെർനെറ്റസിലേക്ക് ഒരു ആപ്ലിക്കേഷൻ മൈഗ്രേറ്റ് ചെയ്യുന്നതിൻ്റെ ആദ്യ ഘട്ടങ്ങളിൽ അവ പ്രസക്തമാകാം, പക്ഷേ റൂട്ട് എടുക്കരുത്.

ഇതിനകം പലർക്കും അറിയാവുന്ന കാര്യങ്ങൾക്ക് അനുസൃതമായി ആപ്ലിക്കേഷൻ്റെ വാസ്തുവിദ്യാ പരിഷ്ക്കരണത്തിന് അനുകൂലമായി അവ ഒഴിവാക്കുക എന്നതാണ് പൊതുവായ ശുപാർശിത മാർഗം. 12-ഘടക ആപ്പ്. എന്നിരുന്നാലും, ഇത് - അപേക്ഷയെ സ്‌റ്റേറ്റ്‌ലെസ് ഫോമിലേക്ക് കൊണ്ടുവരുന്നത് - അനിവാര്യമായും അർത്ഥമാക്കുന്നത് കോഡിൽ മാറ്റങ്ങൾ ആവശ്യമായി വരും എന്നാണ്, കൂടാതെ ബിസിനസ്സിൻ്റെ കഴിവുകൾ/ആവശ്യകതകൾ, തിരഞ്ഞെടുത്ത പാത നടപ്പിലാക്കുന്നതിനും പരിപാലിക്കുന്നതിനുമുള്ള സാധ്യതകൾ എന്നിവയ്‌ക്കിടയിൽ ഒരു ബാലൻസ് കണ്ടെത്തേണ്ടത് ഇവിടെ പ്രധാനമാണ്. .

പി.എസ്

ഞങ്ങളുടെ ബ്ലോഗിലും വായിക്കുക:

• «nginx ഉപയോഗിച്ച് AWS S3-ൽ നിന്നുള്ള ഫയലുകൾ പ്രോക്‌സി ചെയ്യുന്നു";
• «Google-ന്റെ 7 കണ്ടെയ്‌നർ മികച്ച സമ്പ്രദായങ്ങൾ";
• «കണ്ടെയ്നർ അടിസ്ഥാനമാക്കിയുള്ള ആപ്ലിക്കേഷനുകൾ രൂപകൽപ്പന ചെയ്യുന്നതിനുള്ള 7 തത്വങ്ങൾ» (Red Hat-ൽ നിന്ന്);
• «7 ഫാക്ടർ ആപ്പിൽ 12 മിസ്സിംഗ് ഘടകങ്ങൾ".

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