ಕುಬರ್ನೆಟ್ಸ್‌ಗೆ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಸ್ಥಳಾಂತರಿಸುವಾಗ ಸ್ಥಳೀಯ ಫೈಲ್‌ಗಳು

ಕುಬರ್ನೆಟ್ಸ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು CI/CD ಪ್ರಕ್ರಿಯೆಯನ್ನು ನಿರ್ಮಿಸುವಾಗ, ಕೆಲವೊಮ್ಮೆ ಹೊಸ ಮೂಲಸೌಕರ್ಯದ ಅವಶ್ಯಕತೆಗಳು ಮತ್ತು ಅದಕ್ಕೆ ವರ್ಗಾಯಿಸಲಾದ ಅಪ್ಲಿಕೇಶನ್ ನಡುವಿನ ಅಸಾಮರಸ್ಯದ ಸಮಸ್ಯೆ ಉದ್ಭವಿಸುತ್ತದೆ. ನಿರ್ದಿಷ್ಟವಾಗಿ ಹೇಳುವುದಾದರೆ, ಅಪ್ಲಿಕೇಶನ್ ನಿರ್ಮಾಣ ಹಂತದಲ್ಲಿ ಅದನ್ನು ಪಡೆಯುವುದು ಮುಖ್ಯವಾಗಿದೆ один ಚಿತ್ರದಲ್ಲಿ ಬಳಸಲಾಗುವುದು всех ಯೋಜನೆಯ ಪರಿಸರಗಳು ಮತ್ತು ಸಮೂಹಗಳು. ಈ ತತ್ವವು ಸರಿಯಾಗಿದೆ ಗೂಗಲ್ ಪ್ರಕಾರ ಕಂಟೇನರ್ ನಿರ್ವಹಣೆ (ಇದರ ಬಗ್ಗೆ ಒಂದಕ್ಕಿಂತ ಹೆಚ್ಚು ಬಾರಿ ಹೇಳಿದರು ಮತ್ತು ನಮ್ಮ ತಾಂತ್ರಿಕ ವಿಭಾಗ).

ಆದಾಗ್ಯೂ, ಸೈಟ್ನ ಕೋಡ್ ರೆಡಿಮೇಡ್ ಫ್ರೇಮ್ವರ್ಕ್ ಅನ್ನು ಬಳಸುವ ಸಂದರ್ಭಗಳಲ್ಲಿ ನೀವು ಯಾರನ್ನೂ ನೋಡುವುದಿಲ್ಲ, ಅದರ ಬಳಕೆಯು ಅದರ ಮುಂದಿನ ಬಳಕೆಗೆ ನಿರ್ಬಂಧಗಳನ್ನು ವಿಧಿಸುತ್ತದೆ. ಮತ್ತು "ಸಾಮಾನ್ಯ ಪರಿಸರ" ದಲ್ಲಿ ಇದನ್ನು ನಿಭಾಯಿಸಲು ಸುಲಭವಾಗಿದೆ, ಕುಬರ್ನೆಟ್ಸ್ನಲ್ಲಿ ಈ ನಡವಳಿಕೆಯು ಸಮಸ್ಯೆಯಾಗಬಹುದು, ವಿಶೇಷವಾಗಿ ನೀವು ಅದನ್ನು ಮೊದಲ ಬಾರಿಗೆ ಎದುರಿಸಿದಾಗ. ಆವಿಷ್ಕಾರಶೀಲ ಮನಸ್ಸು ಮೂಲಭೂತ ಸೌಕರ್ಯಗಳ ಪರಿಹಾರಗಳೊಂದಿಗೆ ಬರಬಹುದು, ಅದು ಮೊದಲ ನೋಟದಲ್ಲಿ ಸ್ಪಷ್ಟವಾಗಿ ಅಥವಾ ಉತ್ತಮವಾಗಿದೆ ಎಂದು ತೋರುತ್ತದೆ ... ಹೆಚ್ಚಿನ ಸಂದರ್ಭಗಳಲ್ಲಿ ಮಾಡಬಹುದು ಮತ್ತು ಮಾಡಬೇಕು ಎಂಬುದನ್ನು ನೆನಪಿಟ್ಟುಕೊಳ್ಳುವುದು ಬಹಳ ಮುಖ್ಯ ವಾಸ್ತುಶಾಸ್ತ್ರೀಯವಾಗಿ ಪರಿಹರಿಸಬಹುದು.

ಕ್ಲಸ್ಟರ್ ಅನ್ನು ನಿರ್ವಹಿಸುವಾಗ ಅಹಿತಕರ ಪರಿಣಾಮಗಳಿಗೆ ಕಾರಣವಾಗುವ ಫೈಲ್‌ಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು ಜನಪ್ರಿಯ ಪರಿಹಾರ ಪರಿಹಾರಗಳನ್ನು ನೋಡೋಣ ಮತ್ತು ಹೆಚ್ಚು ಸರಿಯಾದ ಮಾರ್ಗವನ್ನು ಸೂಚಿಸಿ.

ಸ್ಥಿರ ಸಂಗ್ರಹಣೆ

ವಿವರಿಸಲು, ಚಿತ್ರಗಳು, ಶೈಲಿಗಳು ಮತ್ತು ಇತರ ವಸ್ತುಗಳ ಸೆಟ್ ಅನ್ನು ಪಡೆಯಲು ಕೆಲವು ರೀತಿಯ ಸ್ಥಿರ ಜನರೇಟರ್ ಅನ್ನು ಬಳಸುವ ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಪರಿಗಣಿಸಿ. ಉದಾಹರಣೆಗೆ, 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