ಕಾನ್ಸಲ್ ಬಳಸಿ ನೊಮಾಡ್ ಕ್ಲಸ್ಟರ್ ಅನ್ನು ಹೊಂದಿಸುವುದು ಮತ್ತು ಗಿಟ್‌ಲ್ಯಾಬ್‌ನೊಂದಿಗೆ ಸಂಯೋಜಿಸುವುದು

ಪರಿಚಯ

ಇತ್ತೀಚೆಗೆ, ಕುಬರ್ನೆಟ್ಸ್ನ ಜನಪ್ರಿಯತೆಯು ವೇಗವಾಗಿ ಬೆಳೆಯುತ್ತಿದೆ - ಹೆಚ್ಚು ಹೆಚ್ಚು ಯೋಜನೆಗಳು ಅದನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತಿವೆ. ನಾನು ನೋಮಾಡ್‌ನಂತಹ ಆರ್ಕೆಸ್ಟ್ರೇಟರ್ ಅನ್ನು ಸ್ಪರ್ಶಿಸಲು ಬಯಸುತ್ತೇನೆ: ಇದು ಈಗಾಗಲೇ HashiCorp ನಿಂದ ಇತರ ಪರಿಹಾರಗಳನ್ನು ಬಳಸುವ ಯೋಜನೆಗಳಿಗೆ ಪರಿಪೂರ್ಣವಾಗಿದೆ, ಉದಾಹರಣೆಗೆ, ವಾಲ್ಟ್ ಮತ್ತು ಕಾನ್ಸುಲ್, ಮತ್ತು ಯೋಜನೆಗಳು ಮೂಲಸೌಕರ್ಯದ ವಿಷಯದಲ್ಲಿ ಸಂಕೀರ್ಣವಾಗಿಲ್ಲ. ಈ ವಸ್ತುವು ನೊಮಾಡ್ ಅನ್ನು ಸ್ಥಾಪಿಸಲು ಸೂಚನೆಗಳನ್ನು ಹೊಂದಿರುತ್ತದೆ, ಎರಡು ನೋಡ್‌ಗಳನ್ನು ಕ್ಲಸ್ಟರ್‌ಗೆ ಸಂಯೋಜಿಸುತ್ತದೆ, ಹಾಗೆಯೇ ನೋಮಾಡ್ ಅನ್ನು ಗಿಟ್‌ಲ್ಯಾಬ್‌ನೊಂದಿಗೆ ಸಂಯೋಜಿಸುತ್ತದೆ.

ಪರೀಕ್ಷಾ ನಿಲುವು

ಪರೀಕ್ಷಾ ಬೆಂಚ್ ಬಗ್ಗೆ ಸ್ವಲ್ಪ: ಮೂರು ವರ್ಚುವಲ್ ಸರ್ವರ್‌ಗಳನ್ನು 2 CPU, 4 RAM, 50 Gb SSD ನ ಗುಣಲಕ್ಷಣಗಳೊಂದಿಗೆ ಬಳಸಲಾಗುತ್ತದೆ, ಇದನ್ನು ಸಾಮಾನ್ಯ ಸ್ಥಳೀಯ ನೆಟ್‌ವರ್ಕ್‌ಗೆ ಸಂಯೋಜಿಸಲಾಗಿದೆ. ಅವರ ಹೆಸರುಗಳು ಮತ್ತು IP ವಿಳಾಸಗಳು:

1. nomad-livelinux-01: 172.30.0.5
2. nomad-livelinux-02: 172.30.0.10
3. ಕಾನ್ಸಲ್-ಲೈವೆಲಿನಕ್ಸ್-01: 172.30.0.15

ಅಲೆಮಾರಿ, ಕಾನ್ಸುಲ್ ಸ್ಥಾಪನೆ. ಅಲೆಮಾರಿ ಸಮೂಹವನ್ನು ರಚಿಸುವುದು

ಮೂಲ ಅನುಸ್ಥಾಪನೆಯೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸೋಣ. ಸೆಟಪ್ ಸರಳವಾಗಿದ್ದರೂ, ಲೇಖನದ ಸಮಗ್ರತೆಯ ಸಲುವಾಗಿ ನಾನು ಅದನ್ನು ವಿವರಿಸುತ್ತೇನೆ: ಅಗತ್ಯವಿದ್ದಾಗ ತ್ವರಿತ ಪ್ರವೇಶಕ್ಕಾಗಿ ಕರಡುಗಳು ಮತ್ತು ಟಿಪ್ಪಣಿಗಳಿಂದ ಇದನ್ನು ರಚಿಸಲಾಗಿದೆ.

ನಾವು ಅಭ್ಯಾಸವನ್ನು ಪ್ರಾರಂಭಿಸುವ ಮೊದಲು, ನಾವು ಸೈದ್ಧಾಂತಿಕ ಭಾಗವನ್ನು ಚರ್ಚಿಸುತ್ತೇವೆ, ಏಕೆಂದರೆ ಈ ಹಂತದಲ್ಲಿ ಭವಿಷ್ಯದ ರಚನೆಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಮುಖ್ಯವಾಗಿದೆ.

ನಾವು ಎರಡು ಅಲೆಮಾರಿ ನೋಡ್ಗಳನ್ನು ಹೊಂದಿದ್ದೇವೆ ಮತ್ತು ನಾವು ಅವುಗಳನ್ನು ಕ್ಲಸ್ಟರ್ ಆಗಿ ಸಂಯೋಜಿಸಲು ಬಯಸುತ್ತೇವೆ ಮತ್ತು ಭವಿಷ್ಯದಲ್ಲಿ ನಮಗೆ ಸ್ವಯಂಚಾಲಿತ ಕ್ಲಸ್ಟರ್ ಸ್ಕೇಲಿಂಗ್ ಅಗತ್ಯವಿರುತ್ತದೆ - ಇದಕ್ಕಾಗಿ ನಮಗೆ ಕಾನ್ಸುಲ್ ಅಗತ್ಯವಿರುತ್ತದೆ. ಈ ಉಪಕರಣದೊಂದಿಗೆ, ಹೊಸ ನೋಡ್‌ಗಳನ್ನು ಕ್ಲಸ್ಟರಿಂಗ್ ಮಾಡುವುದು ಮತ್ತು ಸೇರಿಸುವುದು ತುಂಬಾ ಸರಳವಾದ ಕಾರ್ಯವಾಗುತ್ತದೆ: ರಚಿಸಲಾದ ನೊಮಾಡ್ ನೋಡ್ ಕಾನ್ಸುಲ್ ಏಜೆಂಟ್‌ಗೆ ಸಂಪರ್ಕಿಸುತ್ತದೆ ಮತ್ತು ನಂತರ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ನೊಮಾಡ್ ಕ್ಲಸ್ಟರ್‌ಗೆ ಸಂಪರ್ಕಿಸುತ್ತದೆ. ಆದ್ದರಿಂದ, ಆರಂಭದಲ್ಲಿ ನಾವು ಕಾನ್ಸುಲ್ ಸರ್ವರ್ ಅನ್ನು ಸ್ಥಾಪಿಸುತ್ತೇವೆ, ವೆಬ್ ಪ್ಯಾನೆಲ್‌ಗಾಗಿ ಮೂಲ http ದೃಢೀಕರಣವನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡುತ್ತೇವೆ (ಇದು ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ ಅನುಮತಿಯಿಲ್ಲದೆ ಮತ್ತು ಬಾಹ್ಯ ವಿಳಾಸದಲ್ಲಿ ಪ್ರವೇಶಿಸಬಹುದು), ಹಾಗೆಯೇ ನೊಮಾಡ್ ಸರ್ವರ್‌ಗಳಲ್ಲಿ ಕಾನ್ಸುಲ್ ಏಜೆಂಟ್‌ಗಳು ಸ್ವತಃ, ಅದರ ನಂತರ ನಾವು ಅಲೆಮಾರಿಗಳಿಗೆ ಮಾತ್ರ ಹೋಗುತ್ತೇವೆ.

HashiCorp ನ ಉಪಕರಣಗಳನ್ನು ಸ್ಥಾಪಿಸುವುದು ತುಂಬಾ ಸರಳವಾಗಿದೆ: ಮೂಲಭೂತವಾಗಿ, ನಾವು ಬೈನರಿ ಫೈಲ್ ಅನ್ನು ಬಿನ್ ಡೈರೆಕ್ಟರಿಗೆ ಸರಿಸುತ್ತೇವೆ, ಉಪಕರಣದ ಕಾನ್ಫಿಗರೇಶನ್ ಫೈಲ್ ಅನ್ನು ಹೊಂದಿಸುತ್ತೇವೆ ಮತ್ತು ಅದರ ಸೇವಾ ಫೈಲ್ ಅನ್ನು ರಚಿಸುತ್ತೇವೆ.

ಕಾನ್ಸುಲ್ ಬೈನರಿ ಫೈಲ್ ಅನ್ನು ಡೌನ್‌ಲೋಡ್ ಮಾಡಿ ಮತ್ತು ಅದನ್ನು ಬಳಕೆದಾರರ ಹೋಮ್ ಡೈರೆಕ್ಟರಿಯಲ್ಲಿ ಅನ್ಪ್ಯಾಕ್ ಮಾಡಿ:

root@consul-livelinux-01:~# wget https://releases.hashicorp.com/consul/1.5.0/consul_1.5.0_linux_amd64.zip
root@consul-livelinux-01:~# unzip consul_1.5.0_linux_amd64.zip
root@consul-livelinux-01:~# mv consul /usr/local/bin/

ಈಗ ನಾವು ಮತ್ತಷ್ಟು ಕಾನ್ಫಿಗರೇಶನ್‌ಗಾಗಿ ರೆಡಿಮೇಡ್ ಕಾನ್ಸಲ್ ಬೈನರಿಯನ್ನು ಹೊಂದಿದ್ದೇವೆ.

ಕಾನ್ಸುಲ್ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು, ನಾವು ಕೀಜೆನ್ ಆಜ್ಞೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಅನನ್ಯ ಕೀಲಿಯನ್ನು ರಚಿಸಬೇಕಾಗಿದೆ:

root@consul-livelinux-01:~# consul keygen

ಕೆಳಗಿನ ರಚನೆಯೊಂದಿಗೆ /etc/consul.d/ ಡೈರೆಕ್ಟರಿಯನ್ನು ರಚಿಸುವ ಮೂಲಕ ಕಾನ್ಸುಲ್ ಕಾನ್ಫಿಗರೇಶನ್ ಅನ್ನು ಹೊಂದಿಸಲು ಮುಂದುವರಿಯೋಣ:

/etc/consul.d/
├── bootstrap
│   └── config.json

ಬೂಟ್‌ಸ್ಟ್ರ್ಯಾಪ್ ಡೈರೆಕ್ಟರಿಯು ಕಾನ್ಫಿಗರೇಶನ್ ಫೈಲ್ config.json ಅನ್ನು ಹೊಂದಿರುತ್ತದೆ - ಅದರಲ್ಲಿ ನಾವು ಕಾನ್ಸುಲ್ ಸೆಟ್ಟಿಂಗ್‌ಗಳನ್ನು ಹೊಂದಿಸುತ್ತೇವೆ. ಅದರ ವಿಷಯಗಳು:

{
"bootstrap": true,
"server": true,
"datacenter": "dc1",
"data_dir": "/var/consul",
"encrypt": "your-key",
"log_level": "INFO",
"enable_syslog": true,
"start_join": ["172.30.0.15"]
}

ಮುಖ್ಯ ನಿರ್ದೇಶನಗಳು ಮತ್ತು ಅವುಗಳ ಅರ್ಥಗಳನ್ನು ಪ್ರತ್ಯೇಕವಾಗಿ ನೋಡೋಣ:

• ಬೂಟ್ ಸ್ಟ್ರಾಪ್: ನಿಜ. ಹೊಸ ನೋಡ್‌ಗಳು ಸಂಪರ್ಕಗೊಂಡಿದ್ದರೆ ಅವುಗಳ ಸ್ವಯಂಚಾಲಿತ ಸೇರ್ಪಡೆಯನ್ನು ನಾವು ಸಕ್ರಿಯಗೊಳಿಸುತ್ತೇವೆ. ನಿರೀಕ್ಷಿತ ನೋಡ್‌ಗಳ ನಿಖರ ಸಂಖ್ಯೆಯನ್ನು ನಾವು ಇಲ್ಲಿ ಸೂಚಿಸುವುದಿಲ್ಲ ಎಂದು ನಾನು ಗಮನಿಸುತ್ತೇನೆ.
• ಸರ್ವರ್: ನಿಜ. ಸರ್ವರ್ ಮೋಡ್ ಅನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಿ. ಈ ವರ್ಚುವಲ್ ಗಣಕದಲ್ಲಿ ಕಾನ್ಸುಲ್ ಈ ಕ್ಷಣದಲ್ಲಿ ಸರ್ವರ್ ಮತ್ತು ಮಾಸ್ಟರ್ ಆಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಾರೆ, ನೊಮಾಡ್‌ನ VM ಕ್ಲೈಂಟ್‌ಗಳಾಗಿರುತ್ತದೆ.
• ಡೇಟಾ ಸೆಂಟರ್: dc1. ಕ್ಲಸ್ಟರ್ ರಚಿಸಲು ಡೇಟಾ ಕೇಂದ್ರದ ಹೆಸರನ್ನು ಸೂಚಿಸಿ. ಇದು ಕ್ಲೈಂಟ್‌ಗಳು ಮತ್ತು ಸರ್ವರ್‌ಗಳಲ್ಲಿ ಒಂದೇ ಆಗಿರಬೇಕು.
• ಎನ್‌ಕ್ರಿಪ್ಟ್ ಮಾಡಿ: ನಿಮ್ಮ ಕೀ. ಕೀ, ಇದು ಅನನ್ಯವಾಗಿರಬೇಕು ಮತ್ತು ಎಲ್ಲಾ ಕ್ಲೈಂಟ್‌ಗಳು ಮತ್ತು ಸರ್ವರ್‌ಗಳಲ್ಲಿ ಹೊಂದಿಕೆಯಾಗಬೇಕು. ಕಾನ್ಸಲ್ ಕೀಜೆನ್ ಆಜ್ಞೆಯನ್ನು ಬಳಸಿಕೊಂಡು ರಚಿಸಲಾಗಿದೆ.
• ಪ್ರಾರಂಭಿಸಿ_ಸೇರಿ. ಈ ಪಟ್ಟಿಯಲ್ಲಿ ನಾವು ಸಂಪರ್ಕವನ್ನು ಮಾಡಲಾಗುವ IP ವಿಳಾಸಗಳ ಪಟ್ಟಿಯನ್ನು ಸೂಚಿಸುತ್ತೇವೆ. ಈ ಸಮಯದಲ್ಲಿ ನಾವು ನಮ್ಮ ಸ್ವಂತ ವಿಳಾಸವನ್ನು ಮಾತ್ರ ಬಿಡುತ್ತೇವೆ.

ಈ ಹಂತದಲ್ಲಿ ನಾವು ಕಮಾಂಡ್ ಲೈನ್ ಬಳಸಿ ಕಾನ್ಸುಲ್ ಅನ್ನು ಚಲಾಯಿಸಬಹುದು:

root@consul-livelinux-01:~# /usr/local/bin/consul agent -config-dir /etc/consul.d/bootstrap -ui

ಇದೀಗ ಡೀಬಗ್ ಮಾಡಲು ಇದು ಉತ್ತಮ ಮಾರ್ಗವಾಗಿದೆ, ಆದಾಗ್ಯೂ, ಸ್ಪಷ್ಟ ಕಾರಣಗಳಿಗಾಗಿ ನಡೆಯುತ್ತಿರುವ ಆಧಾರದ ಮೇಲೆ ಈ ವಿಧಾನವನ್ನು ಬಳಸಲು ನಿಮಗೆ ಸಾಧ್ಯವಾಗುವುದಿಲ್ಲ. systemd ಮೂಲಕ ಕಾನ್ಸುಲ್ ಅನ್ನು ನಿರ್ವಹಿಸಲು ಸೇವಾ ಫೈಲ್ ಅನ್ನು ರಚಿಸೋಣ:

root@consul-livelinux-01:~# nano /etc/systemd/system/consul.service

consul.service ಫೈಲ್‌ನ ವಿಷಯಗಳು:

[Unit]
Description=Consul Startup process
After=network.target
 
[Service]
Type=simple
ExecStart=/bin/bash -c '/usr/local/bin/consul agent -config-dir /etc/consul.d/bootstrap -ui' 
TimeoutStartSec=0
 
[Install]
WantedBy=default.target

systemctl ಮೂಲಕ ಕಾನ್ಸುಲ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಿ:

root@consul-livelinux-01:~# systemctl start consul

ಪರಿಶೀಲಿಸೋಣ: ನಮ್ಮ ಸೇವೆಯು ಚಾಲನೆಯಲ್ಲಿರಬೇಕು ಮತ್ತು ಕಾನ್ಸುಲ್ ಸದಸ್ಯರ ಆಜ್ಞೆಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಮೂಲಕ ನಾವು ನಮ್ಮ ಸರ್ವರ್ ಅನ್ನು ನೋಡಬೇಕು:

root@consul-livelinux:/etc/consul.d# consul members
consul-livelinux    172.30.0.15:8301  alive   server  1.5.0  2         dc1  <all>

ಮುಂದಿನ ಹಂತ: Nginx ಅನ್ನು ಸ್ಥಾಪಿಸುವುದು ಮತ್ತು ಪ್ರಾಕ್ಸಿಯಿಂಗ್ ಮತ್ತು http ದೃಢೀಕರಣವನ್ನು ಹೊಂದಿಸುವುದು. ನಾವು ಪ್ಯಾಕೇಜ್ ಮ್ಯಾನೇಜರ್ ಮೂಲಕ nginx ಅನ್ನು ಸ್ಥಾಪಿಸುತ್ತೇವೆ ಮತ್ತು /etc/nginx/sites-enabled ಡೈರೆಕ್ಟರಿಯಲ್ಲಿ ನಾವು ಈ ಕೆಳಗಿನ ವಿಷಯಗಳೊಂದಿಗೆ ಕಾನ್ಫಿಗರೇಶನ್ ಫೈಲ್ consul.conf ಅನ್ನು ರಚಿಸುತ್ತೇವೆ:

upstream consul-auth {
    server localhost:8500;
}

server {

    server_name consul.doman.name;
    
    location / {
      proxy_pass http://consul-auth;
      proxy_set_header Host $host;
      auth_basic_user_file /etc/nginx/.htpasswd;
      auth_basic "Password-protected Area";
    }
}

.htpasswd ಫೈಲ್ ಅನ್ನು ರಚಿಸಲು ಮತ್ತು ಅದಕ್ಕೆ ಬಳಕೆದಾರಹೆಸರು ಮತ್ತು ಪಾಸ್‌ವರ್ಡ್ ಅನ್ನು ರಚಿಸಲು ಮರೆಯಬೇಡಿ. ನಮ್ಮ ಡೊಮೇನ್ ತಿಳಿದಿರುವ ಎಲ್ಲರಿಗೂ ವೆಬ್ ಪ್ಯಾನೆಲ್ ಲಭ್ಯವಾಗದಂತೆ ಈ ಐಟಂ ಅಗತ್ಯವಿದೆ. ಆದಾಗ್ಯೂ, Gitlab ಅನ್ನು ಹೊಂದಿಸುವಾಗ, ನಾವು ಇದನ್ನು ತ್ಯಜಿಸಬೇಕಾಗುತ್ತದೆ - ಇಲ್ಲದಿದ್ದರೆ ನಾವು ನಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ನೋಮಾಡ್‌ಗೆ ನಿಯೋಜಿಸಲು ಸಾಧ್ಯವಾಗುವುದಿಲ್ಲ. ನನ್ನ ಪ್ರಾಜೆಕ್ಟ್‌ನಲ್ಲಿ ಗಿಟ್ಲಾಬ್ ಮತ್ತು ನೊಮಾಡ್ ಎರಡೂ ಗ್ರೇ ವೆಬ್‌ನಲ್ಲಿ ಮಾತ್ರ ಇರುವುದರಿಂದ ಇಲ್ಲಿ ಅಂತಹ ಸಮಸ್ಯೆ ಇಲ್ಲ.

ಉಳಿದ ಎರಡು ಸರ್ವರ್‌ಗಳಲ್ಲಿ ನಾವು ಈ ಕೆಳಗಿನ ಸೂಚನೆಗಳ ಪ್ರಕಾರ ಕಾನ್ಸುಲ್ ಏಜೆಂಟ್‌ಗಳನ್ನು ಸ್ಥಾಪಿಸುತ್ತೇವೆ. ಬೈನರಿ ಫೈಲ್ನೊಂದಿಗೆ ನಾವು ಹಂತಗಳನ್ನು ಪುನರಾವರ್ತಿಸುತ್ತೇವೆ:

root@nomad-livelinux-01:~# wget https://releases.hashicorp.com/consul/1.5.0/consul_1.5.0_linux_amd64.zip
root@nomad-livelinux-01:~# unzip consul_1.5.0_linux_amd64.zip
root@nomad-livelinux-01:~# mv consul /usr/local/bin/

ಹಿಂದಿನ ಸರ್ವರ್‌ನೊಂದಿಗೆ ಸಾದೃಶ್ಯದ ಮೂಲಕ, ಈ ಕೆಳಗಿನ ರಚನೆಯೊಂದಿಗೆ ಕಾನ್ಫಿಗರೇಶನ್ ಫೈಲ್‌ಗಳಿಗಾಗಿ ನಾವು ಡೈರೆಕ್ಟರಿಯನ್ನು ರಚಿಸುತ್ತೇವೆ /etc/consul.d:

/etc/consul.d/
├── client
│   └── config.json

config.json ಫೈಲ್‌ನ ವಿಷಯಗಳು:

{
    "datacenter": "dc1",
    "data_dir": "/opt/consul",
    "log_level": "DEBUG",
    "node_name": "nomad-livelinux-01",
    "server": false,
    "encrypt": "your-private-key",
    "domain": "livelinux",
    "addresses": {
      "dns": "127.0.0.1",
      "https": "0.0.0.0",
      "grpc": "127.0.0.1",
      "http": "127.0.0.1"
    },
    "bind_addr": "172.30.0.5", # локальный адрес вм
    "start_join": ["172.30.0.15"], # удаленный адрес консул сервера
    "ports": {
      "dns": 53
     }

ಬದಲಾವಣೆಗಳನ್ನು ಉಳಿಸಿ ಮತ್ತು ಸೇವಾ ಫೈಲ್, ಅದರ ವಿಷಯಗಳನ್ನು ಹೊಂದಿಸಲು ಮುಂದುವರಿಯಿರಿ:

/etc/systemd/system/consul.service:

[Unit]
Description="HashiCorp Consul - A service mesh solution"
Documentation=https://www.consul.io/
Requires=network-online.target
After=network-online.target

[Service]
User=root
Group=root
ExecStart=/usr/local/bin/consul agent -config-dir=/etc/consul.d/client
ExecReload=/usr/local/bin/consul reload
KillMode=process
Restart=on-failure

[Install]
WantedBy=multi-user.target

ನಾವು ಸರ್ವರ್‌ನಲ್ಲಿ ಕಾನ್ಸಲ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತೇವೆ. ಈಗ, ಪ್ರಾರಂಭದ ನಂತರ, ನಾವು nsul ಸದಸ್ಯರಲ್ಲಿ ಕಾನ್ಫಿಗರ್ ಮಾಡಿದ ಸೇವೆಯನ್ನು ನೋಡಬೇಕು. ಕ್ಲೈಂಟ್‌ನಂತೆ ಕ್ಲಸ್ಟರ್‌ಗೆ ಯಶಸ್ವಿಯಾಗಿ ಸಂಪರ್ಕಗೊಂಡಿದೆ ಎಂದು ಇದು ಅರ್ಥೈಸುತ್ತದೆ. ಎರಡನೇ ಸರ್ವರ್‌ನಲ್ಲಿ ಅದೇ ಪುನರಾವರ್ತಿಸಿ ಮತ್ತು ಅದರ ನಂತರ ನಾವು ನೋಮಾಡ್ ಅನ್ನು ಸ್ಥಾಪಿಸಲು ಮತ್ತು ಕಾನ್ಫಿಗರ್ ಮಾಡಲು ಪ್ರಾರಂಭಿಸಬಹುದು.

ನೊಮಾಡ್ನ ಹೆಚ್ಚು ವಿವರವಾದ ಸ್ಥಾಪನೆಯನ್ನು ಅದರ ಅಧಿಕೃತ ದಾಖಲಾತಿಯಲ್ಲಿ ವಿವರಿಸಲಾಗಿದೆ. ಎರಡು ಸಾಂಪ್ರದಾಯಿಕ ಅನುಸ್ಥಾಪನಾ ವಿಧಾನಗಳಿವೆ: ಬೈನರಿ ಫೈಲ್ ಅನ್ನು ಡೌನ್‌ಲೋಡ್ ಮಾಡುವುದು ಮತ್ತು ಮೂಲದಿಂದ ಕಂಪೈಲ್ ಮಾಡುವುದು. ನಾನು ಮೊದಲ ವಿಧಾನವನ್ನು ಆರಿಸಿಕೊಳ್ಳುತ್ತೇನೆ.

ಹೇಳಿಕೆಯನ್ನು: ಯೋಜನೆಯು ತ್ವರಿತವಾಗಿ ಅಭಿವೃದ್ಧಿ ಹೊಂದುತ್ತಿದೆ, ಹೊಸ ನವೀಕರಣಗಳನ್ನು ಹೆಚ್ಚಾಗಿ ಬಿಡುಗಡೆ ಮಾಡಲಾಗುತ್ತದೆ. ಬಹುಶಃ ಈ ಲೇಖನವು ಪೂರ್ಣಗೊಳ್ಳುವ ಹೊತ್ತಿಗೆ ಹೊಸ ಆವೃತ್ತಿಯನ್ನು ಬಿಡುಗಡೆ ಮಾಡಲಾಗುತ್ತದೆ. ಆದ್ದರಿಂದ, ಓದುವ ಮೊದಲು, ಪ್ರಸ್ತುತ ನೋಮಾಡ್ ಆವೃತ್ತಿಯನ್ನು ಪರಿಶೀಲಿಸಲು ಮತ್ತು ಅದನ್ನು ಡೌನ್‌ಲೋಡ್ ಮಾಡಲು ನಾನು ಶಿಫಾರಸು ಮಾಡುತ್ತೇವೆ.

root@nomad-livelinux-01:~# wget https://releases.hashicorp.com/nomad/0.9.1/nomad_0.9.1_linux_amd64.zip
root@nomad-livelinux-01:~# unzip nomad_0.9.1_linux_amd64.zip
root@nomad-livelinux-01:~# mv nomad /usr/local/bin/
root@nomad-livelinux-01:~# nomad -autocomplete-install
root@nomad-livelinux-01:~# complete -C /usr/local/bin/nomad nomad
root@nomad-livelinux-01:~# mkdir /etc/nomad.d

ಅನ್ಪ್ಯಾಕ್ ಮಾಡಿದ ನಂತರ, ನಾವು 65 MB ತೂಕದ Nomad ಬೈನರಿ ಫೈಲ್ ಅನ್ನು ಸ್ವೀಕರಿಸುತ್ತೇವೆ - ಅದನ್ನು /usr/local/bin ಗೆ ಸರಿಸಬೇಕು.

ನೋಮಾಡ್‌ಗಾಗಿ ಡೇಟಾ ಡೈರೆಕ್ಟರಿಯನ್ನು ರಚಿಸೋಣ ಮತ್ತು ಅದರ ಸೇವಾ ಫೈಲ್ ಅನ್ನು ಸಂಪಾದಿಸೋಣ (ಇದು ಆರಂಭದಲ್ಲಿ ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲ):

root@nomad-livelinux-01:~# mkdir --parents /opt/nomad
root@nomad-livelinux-01:~# nano /etc/systemd/system/nomad.service

ಕೆಳಗಿನ ಸಾಲುಗಳನ್ನು ಅಲ್ಲಿ ಅಂಟಿಸಿ:

[Unit]
Description=Nomad
Documentation=https://nomadproject.io/docs/
Wants=network-online.target
After=network-online.target

[Service]
ExecReload=/bin/kill -HUP $MAINPID
ExecStart=/usr/local/bin/nomad agent -config /etc/nomad.d
KillMode=process
KillSignal=SIGINT
LimitNOFILE=infinity
LimitNPROC=infinity
Restart=on-failure
RestartSec=2
StartLimitBurst=3
StartLimitIntervalSec=10
TasksMax=infinity

[Install]
WantedBy=multi-user.target

ಆದಾಗ್ಯೂ, ನಾವು ಅಲೆಮಾರಿಯನ್ನು ಪ್ರಾರಂಭಿಸಲು ಯಾವುದೇ ಆತುರವಿಲ್ಲ - ನಾವು ಅದರ ಕಾನ್ಫಿಗರೇಶನ್ ಫೈಲ್ ಅನ್ನು ಇನ್ನೂ ರಚಿಸಿಲ್ಲ:

root@nomad-livelinux-01:~# mkdir --parents /etc/nomad.d
root@nomad-livelinux-01:~# chmod 700 /etc/nomad.d
root@nomad-livelinux-01:~# nano /etc/nomad.d/nomad.hcl
root@nomad-livelinux-01:~# nano /etc/nomad.d/server.hcl

ಅಂತಿಮ ಡೈರೆಕ್ಟರಿ ರಚನೆಯು ಈ ಕೆಳಗಿನಂತಿರುತ್ತದೆ:

/etc/nomad.d/
├── nomad.hcl
└── server.hcl

nomad.hcl ಫೈಲ್ ಈ ಕೆಳಗಿನ ಸಂರಚನೆಯನ್ನು ಹೊಂದಿರಬೇಕು:

datacenter = "dc1"
data_dir = "/opt/nomad"

server.hcl ಫೈಲ್‌ನ ವಿಷಯಗಳು:

server {
  enabled = true
  bootstrap_expect = 1
}

consul {
  address             = "127.0.0.1:8500"
  server_service_name = "nomad"
  client_service_name = "nomad-client"
  auto_advertise      = true
  server_auto_join    = true
  client_auto_join    = true
}

bind_addr = "127.0.0.1" 

advertise {
  http = "172.30.0.5"
}

client {
  enabled = true
}

ಎರಡನೇ ಸರ್ವರ್‌ನಲ್ಲಿ ಕಾನ್ಫಿಗರೇಶನ್ ಫೈಲ್ ಅನ್ನು ಬದಲಾಯಿಸಲು ಮರೆಯಬೇಡಿ - ಅಲ್ಲಿ ನೀವು http ನಿರ್ದೇಶನದ ಮೌಲ್ಯವನ್ನು ಬದಲಾಯಿಸಬೇಕಾಗುತ್ತದೆ.

ಈ ಹಂತದಲ್ಲಿ ಕೊನೆಯ ವಿಷಯವೆಂದರೆ ಪ್ರಾಕ್ಸಿ ಮಾಡಲು ಮತ್ತು http ದೃಢೀಕರಣವನ್ನು ಹೊಂದಿಸಲು Nginx ಅನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡುವುದು. nomad.conf ಫೈಲ್‌ನ ವಿಷಯಗಳು:

upstream nomad-auth {
        server 172.30.0.5:4646;
}

server {

        server_name nomad.domain.name;
        
        location / {
	        proxy_pass http://nomad-auth;
	        proxy_set_header Host $host;
	        auth_basic_user_file /etc/nginx/.htpasswd;
		   auth_basic "Password-protected Area";
        }
        
}

ಈಗ ನಾವು ಬಾಹ್ಯ ನೆಟ್ವರ್ಕ್ ಮೂಲಕ ವೆಬ್ ಫಲಕವನ್ನು ಪ್ರವೇಶಿಸಬಹುದು. ಸಂಪರ್ಕಿಸಿ ಮತ್ತು ಸರ್ವರ್‌ಗಳ ಪುಟಕ್ಕೆ ಹೋಗಿ:

ಚಿತ್ರ 1. ನೊಮಾಡ್ ಕ್ಲಸ್ಟರ್‌ನಲ್ಲಿರುವ ಸರ್ವರ್‌ಗಳ ಪಟ್ಟಿ

ಎರಡೂ ಸರ್ವರ್‌ಗಳನ್ನು ಫಲಕದಲ್ಲಿ ಯಶಸ್ವಿಯಾಗಿ ಪ್ರದರ್ಶಿಸಲಾಗುತ್ತದೆ, ನಾಮಾಡ್ ನೋಡ್ ಸ್ಥಿತಿ ಆಜ್ಞೆಯ ಔಟ್‌ಪುಟ್‌ನಲ್ಲಿ ನಾವು ಒಂದೇ ವಿಷಯವನ್ನು ನೋಡುತ್ತೇವೆ:

ಚಿತ್ರ 2. ನೊಮ್ಯಾಡ್ ನೋಡ್ ಸ್ಥಿತಿ ಆಜ್ಞೆಯ ಔಟ್ಪುಟ್

ಕಾನ್ಸುಲ್ ಬಗ್ಗೆ ಏನು? ನೋಡೋಣ. ಕಾನ್ಸುಲ್ ನಿಯಂತ್ರಣ ಫಲಕಕ್ಕೆ, ನೋಡ್‌ಗಳ ಪುಟಕ್ಕೆ ಹೋಗಿ:

ಚಿತ್ರ 3. ಕಾನ್ಸುಲ್ ಕ್ಲಸ್ಟರ್‌ನಲ್ಲಿರುವ ನೋಡ್‌ಗಳ ಪಟ್ಟಿ

ಈಗ ನಾವು ಕಾನ್ಸುಲ್ ಜೊತೆಯಲ್ಲಿ ಕೆಲಸ ಮಾಡುವ ತಯಾರಾದ ಅಲೆಮಾರಿಗಳನ್ನು ಹೊಂದಿದ್ದೇವೆ. ಅಂತಿಮ ಹಂತದಲ್ಲಿ, ನಾವು ಮೋಜಿನ ಭಾಗಕ್ಕೆ ಹೋಗುತ್ತೇವೆ: ಗಿಟ್ಲಾಬ್‌ನಿಂದ ನೊಮಾಡ್‌ಗೆ ಡಾಕರ್ ಕಂಟೈನರ್‌ಗಳ ವಿತರಣೆಯನ್ನು ಹೊಂದಿಸುವುದು ಮತ್ತು ಅದರ ಕೆಲವು ವಿಶಿಷ್ಟ ವೈಶಿಷ್ಟ್ಯಗಳ ಬಗ್ಗೆ ಮಾತನಾಡುವುದು.

Gitlab ರನ್ನರ್ ಅನ್ನು ರಚಿಸಲಾಗುತ್ತಿದೆ

ನೊಮಾಡ್‌ಗೆ ಡಾಕರ್ ಚಿತ್ರಗಳನ್ನು ನಿಯೋಜಿಸಲು, ನಾವು ಒಳಗೆ ನೊಮಾಡ್ ಬೈನರಿ ಫೈಲ್‌ನೊಂದಿಗೆ ಪ್ರತ್ಯೇಕ ರನ್ನರ್ ಅನ್ನು ಬಳಸುತ್ತೇವೆ (ಇಲ್ಲಿ, ಮೂಲಕ, ಹ್ಯಾಶಿಕಾರ್ಪ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳ ಮತ್ತೊಂದು ವೈಶಿಷ್ಟ್ಯವನ್ನು ನಾವು ಗಮನಿಸಬಹುದು - ಪ್ರತ್ಯೇಕವಾಗಿ ಅವು ಒಂದೇ ಬೈನರಿ ಫೈಲ್). ಅದನ್ನು ರನ್ನರ್ ಡೈರೆಕ್ಟರಿಗೆ ಅಪ್ಲೋಡ್ ಮಾಡಿ. ಕೆಳಗಿನ ವಿಷಯದೊಂದಿಗೆ ಸರಳವಾದ ಡಾಕರ್‌ಫೈಲ್ ಅನ್ನು ರಚಿಸೋಣ:

FROM alpine:3.9
RUN apk add --update --no-cache libc6-compat gettext
COPY nomad /usr/local/bin/nomad

ಅದೇ ಯೋಜನೆಯಲ್ಲಿ ನಾವು .gitlab-ci.yml ಅನ್ನು ರಚಿಸುತ್ತೇವೆ:

variables:
  DOCKER_IMAGE: nomad/nomad-deploy
  DOCKER_REGISTRY: registry.domain.name
 

stages:
  - build

build:
  stage: build
  image: ${DOCKER_REGISTRY}/nomad/alpine:3
  script:
    - tag=${DOCKER_REGISTRY}/${DOCKER_IMAGE}:latest
    - docker build --pull -t ${tag} -f Dockerfile .
    - docker push ${tag}

ಪರಿಣಾಮವಾಗಿ, ನಾವು ಗಿಟ್ಲಾಬ್ ರಿಜಿಸ್ಟ್ರಿಯಲ್ಲಿ ನೊಮಾಡ್ ರನ್ನರ್‌ನ ಲಭ್ಯವಿರುವ ಚಿತ್ರವನ್ನು ಹೊಂದಿದ್ದೇವೆ, ಈಗ ನಾವು ನೇರವಾಗಿ ಪ್ರಾಜೆಕ್ಟ್ ರೆಪೊಸಿಟರಿಗೆ ಹೋಗಬಹುದು, ಪೈಪ್‌ಲೈನ್ ಅನ್ನು ರಚಿಸಬಹುದು ಮತ್ತು ನೊಮಾಡ್‌ನ ಅಲೆಮಾರಿ ಕೆಲಸವನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡಬಹುದು.

ಪ್ರಾಜೆಕ್ಟ್ ಸೆಟಪ್

ಅಲೆಮಾರಿಗಾಗಿ ಕೆಲಸದ ಫೈಲ್‌ನೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸೋಣ. ಈ ಲೇಖನದಲ್ಲಿ ನನ್ನ ಯೋಜನೆಯು ಸಾಕಷ್ಟು ಪ್ರಾಚೀನವಾಗಿರುತ್ತದೆ: ಇದು ಒಂದು ಕಾರ್ಯವನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ. .gitlab-ci ನ ವಿಷಯಗಳು ಈ ಕೆಳಗಿನಂತಿರುತ್ತವೆ:

variables:
  NOMAD_ADDR: http://nomad.address.service:4646
  DOCKER_REGISTRY: registry.domain.name
  DOCKER_IMAGE: example/project

stages:
  - build
  - deploy

build:
  stage: build
  image: ${DOCKER_REGISTRY}/nomad-runner/alpine:3
  script:
    - tag=${DOCKER_REGISTRY}/${DOCKER_IMAGE}:${CI_COMMIT_SHORT_SHA}
    - docker build --pull -t ${tag} -f Dockerfile .
    - docker push ${tag}


deploy:
  stage: deploy
  image: registry.example.com/nomad/nomad-runner:latest
  script:
    - envsubst '${CI_COMMIT_SHORT_SHA}' < project.nomad > job.nomad
    - cat job.nomad
    - nomad validate job.nomad
    - nomad plan job.nomad || if [ $? -eq 255 ]; then exit 255; else echo "success"; fi
    - nomad run job.nomad
  environment:
    name: production
  allow_failure: false
  when: manual

ಇಲ್ಲಿ ನಿಯೋಜನೆಯು ಹಸ್ತಚಾಲಿತವಾಗಿ ಸಂಭವಿಸುತ್ತದೆ, ಆದರೆ ಪ್ರಾಜೆಕ್ಟ್ ಡೈರೆಕ್ಟರಿಯ ವಿಷಯಗಳನ್ನು ಬದಲಾಯಿಸಲು ನೀವು ಅದನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡಬಹುದು. ಪೈಪ್ಲೈನ್ ​​ಎರಡು ಹಂತಗಳನ್ನು ಒಳಗೊಂಡಿದೆ: ಚಿತ್ರದ ಜೋಡಣೆ ಮತ್ತು ಅಲೆಮಾರಿಗಳಿಗೆ ಅದರ ನಿಯೋಜನೆ. ಮೊದಲ ಹಂತದಲ್ಲಿ, ನಾವು ಡಾಕರ್ ಚಿತ್ರವನ್ನು ಜೋಡಿಸುತ್ತೇವೆ ಮತ್ತು ಅದನ್ನು ನಮ್ಮ ರಿಜಿಸ್ಟ್ರಿಗೆ ತಳ್ಳುತ್ತೇವೆ ಮತ್ತು ಎರಡನೆಯದಾಗಿ ನಾವು ನೋಮಾಡ್ನಲ್ಲಿ ನಮ್ಮ ಕೆಲಸವನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತೇವೆ.

job "monitoring-status" {
    datacenters = ["dc1"]
    migrate {
        max_parallel = 3
        health_check = "checks"
        min_healthy_time = "15s"
        healthy_deadline = "5m"
    }

    group "zhadan.ltd" {
        count = 1
        update {
            max_parallel      = 1
            min_healthy_time  = "30s"
            healthy_deadline  = "5m"
            progress_deadline = "10m"
            auto_revert       = true
        }
        task "service-monitoring" {
            driver = "docker"

            config {
                image = "registry.domain.name/example/project:${CI_COMMIT_SHORT_SHA}"
                force_pull = true
                auth {
                    username = "gitlab_user"
                    password = "gitlab_password"
                }
                port_map {
                    http = 8000
                }
            }
            resources {
                network {
                    port "http" {}
                }
            }
        }
    }
}

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

# Download the policy and token role
$ curl https://nomadproject.io/data/vault/nomad-server-policy.hcl -O -s -L
$ curl https://nomadproject.io/data/vault/nomad-cluster-role.json -O -s -L

# Write the policy to Vault
$ vault policy write nomad-server nomad-server-policy.hcl

# Create the token role with Vault
$ vault write /auth/token/roles/nomad-cluster @nomad-cluster-role.json

ಈಗ, ಅಗತ್ಯ ನೀತಿಗಳನ್ನು ರಚಿಸಿದ ನಂತರ, ನಾವು job.nomad ಫೈಲ್‌ನಲ್ಲಿ ಟಾಸ್ಕ್ ಬ್ಲಾಕ್‌ನಲ್ಲಿ ವಾಲ್ಟ್‌ನೊಂದಿಗೆ ಏಕೀಕರಣವನ್ನು ಸೇರಿಸುತ್ತೇವೆ:

vault {
  enabled = true
  address = "https://vault.domain.name:8200"
  token = "token"
}

ನಾನು ಟೋಕನ್ ಮೂಲಕ ಅಧಿಕಾರವನ್ನು ಬಳಸುತ್ತೇನೆ ಮತ್ತು ಅದನ್ನು ನೇರವಾಗಿ ಇಲ್ಲಿ ನೋಂದಾಯಿಸುತ್ತೇನೆ, ಅಲೆಮಾರಿ ಏಜೆಂಟ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸುವಾಗ ಟೋಕನ್ ಅನ್ನು ವೇರಿಯಬಲ್ ಆಗಿ ನಿರ್ದಿಷ್ಟಪಡಿಸುವ ಆಯ್ಕೆಯೂ ಇದೆ:

$ VAULT_TOKEN=<token> nomad agent -config /path/to/config

ಈಗ ನಾವು ವಾಲ್ಟ್‌ನೊಂದಿಗೆ ಕೀಗಳನ್ನು ಬಳಸಬಹುದು. ಕಾರ್ಯಾಚರಣೆಯ ತತ್ವವು ಸರಳವಾಗಿದೆ: ನಾವು ನೊಮಾಡ್ ಕೆಲಸದಲ್ಲಿ ಫೈಲ್ ಅನ್ನು ರಚಿಸುತ್ತೇವೆ ಅದು ಅಸ್ಥಿರ ಮೌಲ್ಯಗಳನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ, ಉದಾಹರಣೆಗೆ:

template {
                data = <<EOH
{{with secret "secrets/pipeline-keys"}}
REGISTRY_LOGIN="{{ .Data.REGISTRY_LOGIN }}"
REGISTRY_PASSWORD="{{ .Data.REGISTRY_LOGIN }}{{ end }}"

EOH
    destination = "secrets/service-name.env"
    env = true
}

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

ಲೇಖಕ: ಇಲ್ಯಾ ಆಂಡ್ರೀವ್, ಅಲೆಕ್ಸಿ ಝಡಾನ್ ಮತ್ತು ಲೈವ್ ಲಿನಕ್ಸ್ ತಂಡದಿಂದ ಸಂಪಾದಿಸಲಾಗಿದೆ


ಮೂಲ: www.habr.com