ਕੌਂਸਲ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਨੋਮੈਡ ਕਲੱਸਟਰ ਸਥਾਪਤ ਕਰਨਾ ਅਤੇ ਗਿਟਲੈਬ ਨਾਲ ਏਕੀਕ੍ਰਿਤ ਕਰਨਾ

ਜਾਣ ਪਛਾਣ

ਹਾਲ ਹੀ ਵਿੱਚ, ਕੁਬਰਨੇਟਸ ਦੀ ਪ੍ਰਸਿੱਧੀ ਤੇਜ਼ੀ ਨਾਲ ਵਧ ਰਹੀ ਹੈ - ਵੱਧ ਤੋਂ ਵੱਧ ਪ੍ਰੋਜੈਕਟ ਇਸਨੂੰ ਲਾਗੂ ਕਰ ਰਹੇ ਹਨ. ਮੈਂ ਨੋਮੈਡ ਵਰਗੇ ਆਰਕੈਸਟਰੇਟਰ ਨੂੰ ਛੂਹਣਾ ਚਾਹੁੰਦਾ ਸੀ: ਇਹ ਉਹਨਾਂ ਪ੍ਰੋਜੈਕਟਾਂ ਲਈ ਸੰਪੂਰਨ ਹੈ ਜੋ ਪਹਿਲਾਂ ਹੀ 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. consul-livelinux-01: 172.30.0.15

Nomad, Consul ਦੀ ਸਥਾਪਨਾ. ਨੋਮੈਡ ਕਲੱਸਟਰ ਬਣਾਉਣਾ

ਆਉ ਬੁਨਿਆਦੀ ਇੰਸਟਾਲੇਸ਼ਨ ਨਾਲ ਸ਼ੁਰੂ ਕਰੀਏ. ਹਾਲਾਂਕਿ ਸੈੱਟਅੱਪ ਸਧਾਰਨ ਸੀ, ਮੈਂ ਲੇਖ ਦੀ ਇਕਸਾਰਤਾ ਦੀ ਖ਼ਾਤਰ ਇਸਦਾ ਵਰਣਨ ਕਰਾਂਗਾ: ਇਹ ਜ਼ਰੂਰੀ ਤੌਰ 'ਤੇ ਲੋੜ ਪੈਣ 'ਤੇ ਤੁਰੰਤ ਪਹੁੰਚ ਲਈ ਡਰਾਫਟ ਅਤੇ ਨੋਟਸ ਤੋਂ ਬਣਾਇਆ ਗਿਆ ਸੀ।

ਅਭਿਆਸ ਸ਼ੁਰੂ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ, ਅਸੀਂ ਸਿਧਾਂਤਕ ਹਿੱਸੇ ਦੀ ਚਰਚਾ ਕਰਾਂਗੇ, ਕਿਉਂਕਿ ਇਸ ਪੜਾਅ 'ਤੇ ਭਵਿੱਖ ਦੇ ਢਾਂਚੇ ਨੂੰ ਸਮਝਣਾ ਮਹੱਤਵਪੂਰਨ ਹੈ।

ਸਾਡੇ ਕੋਲ ਦੋ ਨੋਮੈਡ ਨੋਡ ਹਨ ਅਤੇ ਅਸੀਂ ਉਹਨਾਂ ਨੂੰ ਇੱਕ ਕਲੱਸਟਰ ਵਿੱਚ ਜੋੜਨਾ ਚਾਹੁੰਦੇ ਹਾਂ, ਅਤੇ ਭਵਿੱਖ ਵਿੱਚ ਸਾਨੂੰ ਆਟੋਮੈਟਿਕ ਕਲੱਸਟਰ ਸਕੇਲਿੰਗ ਦੀ ਵੀ ਲੋੜ ਪਵੇਗੀ - ਇਸਦੇ ਲਈ ਸਾਨੂੰ ਕੌਂਸਲ ਦੀ ਲੋੜ ਪਵੇਗੀ। ਇਸ ਟੂਲ ਦੇ ਨਾਲ, ਨਵੇਂ ਨੋਡਸ ਨੂੰ ਕਲੱਸਟਰ ਕਰਨਾ ਅਤੇ ਜੋੜਨਾ ਇੱਕ ਬਹੁਤ ਹੀ ਸਧਾਰਨ ਕੰਮ ਬਣ ਜਾਂਦਾ ਹੈ: ਬਣਾਇਆ ਗਿਆ ਨੋਮਡ ਨੋਡ ਕੌਂਸਲ ਏਜੰਟ ਨਾਲ ਜੁੜਦਾ ਹੈ, ਅਤੇ ਫਿਰ ਮੌਜੂਦਾ ਨੋਮਡ ਕਲੱਸਟਰ ਨਾਲ ਜੁੜਦਾ ਹੈ। ਇਸ ਲਈ, ਸ਼ੁਰੂ ਵਿੱਚ ਅਸੀਂ ਕੌਂਸਲ ਸਰਵਰ ਨੂੰ ਸਥਾਪਿਤ ਕਰਾਂਗੇ, ਵੈਬ ਪੈਨਲ ਲਈ ਮੂਲ 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/

ਹੁਣ ਸਾਡੇ ਕੋਲ ਹੋਰ ਸੰਰਚਨਾ ਲਈ ਇੱਕ ਤਿਆਰ-ਕੀਤੀ ਕੌਂਸਲ ਬਾਇਨਰੀ ਹੈ।

Consul ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ, ਸਾਨੂੰ keygen ਕਮਾਂਡ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਵਿਲੱਖਣ ਕੁੰਜੀ ਬਣਾਉਣ ਦੀ ਲੋੜ ਹੈ:

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"]
}

ਆਉ ਮੁੱਖ ਨਿਰਦੇਸ਼ਾਂ ਅਤੇ ਉਹਨਾਂ ਦੇ ਅਰਥਾਂ ਨੂੰ ਵੱਖਰੇ ਤੌਰ 'ਤੇ ਵੇਖੀਏ:

• ਬੂਟਸਟਰੈਪ: ਸੱਚ ਹੈ। ਅਸੀਂ ਨਵੇਂ ਨੋਡਾਂ ਦੇ ਆਟੋਮੈਟਿਕ ਜੋੜ ਨੂੰ ਸਮਰੱਥ ਬਣਾਉਂਦੇ ਹਾਂ ਜੇਕਰ ਉਹ ਜੁੜੇ ਹੋਏ ਹਨ। ਮੈਂ ਨੋਟ ਕਰਦਾ ਹਾਂ ਕਿ ਅਸੀਂ ਇੱਥੇ ਸੰਭਾਵਿਤ ਨੋਡਾਂ ਦੀ ਸਹੀ ਸੰਖਿਆ ਨਹੀਂ ਦਰਸਾਉਂਦੇ ਹਾਂ।
• ਸਰਵਰ: ਸੱਚ ਹੈ। ਸਰਵਰ ਮੋਡ ਨੂੰ ਸਮਰੱਥ ਬਣਾਓ। ਇਸ ਵਰਚੁਅਲ ਮਸ਼ੀਨ 'ਤੇ ਕੌਂਸਲ ਇਸ ਸਮੇਂ ਇਕੋ ਸਰਵਰ ਅਤੇ ਮਾਸਟਰ ਦੇ ਤੌਰ 'ਤੇ ਕੰਮ ਕਰੇਗਾ, Nomad's VM ਗਾਹਕ ਹੋਣਗੇ।
• ਡਾਟਾਸੈਂਟਰ: dc1. ਕਲੱਸਟਰ ਬਣਾਉਣ ਲਈ ਡੇਟਾ ਸੈਂਟਰ ਦਾ ਨਾਮ ਦਿਓ। ਇਹ ਕਲਾਇੰਟਸ ਅਤੇ ਸਰਵਰ ਦੋਵਾਂ 'ਤੇ ਇੱਕੋ ਜਿਹਾ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ।
• ਏਨਕ੍ਰਿਪਟ: ਤੁਹਾਡੀ-ਕੁੰਜੀ. ਕੁੰਜੀ, ਜੋ ਕਿ ਵਿਲੱਖਣ ਵੀ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ ਅਤੇ ਸਾਰੇ ਕਲਾਇੰਟਾਂ ਅਤੇ ਸਰਵਰਾਂ 'ਤੇ ਮੇਲ ਖਾਂਦੀ ਹੈ। consul keygen ਕਮਾਂਡ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਤਿਆਰ ਕੀਤਾ ਗਿਆ।
• start_join. ਇਸ ਸੂਚੀ ਵਿੱਚ ਅਸੀਂ IP ਪਤਿਆਂ ਦੀ ਇੱਕ ਸੂਚੀ ਦਰਸਾਉਂਦੇ ਹਾਂ ਜਿਸ ਨਾਲ ਕੁਨੈਕਸ਼ਨ ਬਣਾਇਆ ਜਾਵੇਗਾ। ਫਿਲਹਾਲ ਅਸੀਂ ਸਿਰਫ ਆਪਣਾ ਪਤਾ ਹੀ ਛੱਡਦੇ ਹਾਂ।

ਇਸ ਬਿੰਦੂ 'ਤੇ ਅਸੀਂ ਕਮਾਂਡ ਲਾਈਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕੌਂਸਲ ਚਲਾ ਸਕਦੇ ਹਾਂ:

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

ਇਹ ਹੁਣ ਡੀਬੱਗ ਕਰਨ ਦਾ ਇੱਕ ਵਧੀਆ ਤਰੀਕਾ ਹੈ, ਹਾਲਾਂਕਿ, ਤੁਸੀਂ ਸਪੱਸ਼ਟ ਕਾਰਨਾਂ ਕਰਕੇ ਇਸ ਵਿਧੀ ਦੀ ਨਿਰੰਤਰ ਵਰਤੋਂ ਕਰਨ ਦੇ ਯੋਗ ਨਹੀਂ ਹੋਵੋਗੇ। ਆਉ ਸਿਸਟਮਡ ਦੁਆਰਾ ਕੌਂਸਲ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਨ ਲਈ ਇੱਕ ਸੇਵਾ ਫਾਈਲ ਬਣਾਈਏ:

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

ਸਿਸਟਮਸੀਟੀਐਲ ਦੁਆਰਾ ਕੌਂਸਲ ਲਾਂਚ ਕਰੋ:

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 ਸੈਟ ਅਪ ਕਰਦੇ ਸਮੇਂ, ਸਾਨੂੰ ਇਸ ਨੂੰ ਛੱਡਣਾ ਪਏਗਾ - ਨਹੀਂ ਤਾਂ ਅਸੀਂ ਆਪਣੀ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਨੋਮੈਡ 'ਤੇ ਤਾਇਨਾਤ ਕਰਨ ਦੇ ਯੋਗ ਨਹੀਂ ਹੋਵਾਂਗੇ। ਮੇਰੇ ਪ੍ਰੋਜੈਕਟ ਵਿੱਚ, Gitlab ਅਤੇ Nomad ਦੋਵੇਂ ਸਿਰਫ ਸਲੇਟੀ ਵੈੱਬ 'ਤੇ ਹਨ, ਇਸ ਲਈ ਇੱਥੇ ਅਜਿਹੀ ਕੋਈ ਸਮੱਸਿਆ ਨਹੀਂ ਹੈ।

ਬਾਕੀ ਦੇ ਦੋ ਸਰਵਰਾਂ 'ਤੇ ਅਸੀਂ ਨਿਮਨਲਿਖਤ ਨਿਰਦੇਸ਼ਾਂ ਦੇ ਅਨੁਸਾਰ ਕੌਂਸਲ ਏਜੰਟ ਸਥਾਪਤ ਕਰਦੇ ਹਾਂ। ਅਸੀਂ ਬਾਈਨਰੀ ਫਾਈਲ ਨਾਲ ਕਦਮਾਂ ਨੂੰ ਦੁਹਰਾਉਂਦੇ ਹਾਂ:

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 ਮੈਂਬਰਾਂ ਵਿੱਚ ਕੌਂਫਿਗਰ ਕੀਤੀ ਸੇਵਾ ਦੇਖਣੀ ਚਾਹੀਦੀ ਹੈ। ਇਸ ਦਾ ਮਤਲਬ ਹੋਵੇਗਾ ਕਿ ਇਹ ਕਲੱਸਟਰ ਨਾਲ ਕਲਾਇੰਟ ਦੇ ਤੌਰ 'ਤੇ ਸਫਲਤਾਪੂਰਵਕ ਜੁੜ ਗਿਆ ਹੈ। ਦੂਜੇ ਸਰਵਰ 'ਤੇ ਉਸੇ ਨੂੰ ਦੁਹਰਾਓ ਅਤੇ ਉਸ ਤੋਂ ਬਾਅਦ ਅਸੀਂ ਨੋਮੈਡ ਨੂੰ ਸਥਾਪਿਤ ਅਤੇ ਸੰਰਚਿਤ ਕਰਨਾ ਸ਼ੁਰੂ ਕਰ ਸਕਦੇ ਹਾਂ।

Nomad ਦੀ ਵਧੇਰੇ ਵਿਸਤ੍ਰਿਤ ਸਥਾਪਨਾ ਨੂੰ ਇਸਦੇ ਅਧਿਕਾਰਤ ਦਸਤਾਵੇਜ਼ਾਂ ਵਿੱਚ ਦਰਸਾਇਆ ਗਿਆ ਹੈ। ਇੱਥੇ ਦੋ ਰਵਾਇਤੀ ਇੰਸਟਾਲੇਸ਼ਨ ਵਿਧੀਆਂ ਹਨ: ਇੱਕ ਬਾਈਨਰੀ ਫਾਈਲ ਨੂੰ ਡਾਊਨਲੋਡ ਕਰਨਾ ਅਤੇ ਸਰੋਤ ਤੋਂ ਕੰਪਾਇਲ ਕਰਨਾ। ਮੈਂ ਪਹਿਲਾ ਤਰੀਕਾ ਚੁਣਾਂਗਾ।

ਟਿੱਪਣੀ: ਪ੍ਰੋਜੈਕਟ ਬਹੁਤ ਤੇਜ਼ੀ ਨਾਲ ਵਿਕਾਸ ਕਰ ਰਿਹਾ ਹੈ, ਨਵੇਂ ਅਪਡੇਟਸ ਅਕਸਰ ਜਾਰੀ ਕੀਤੇ ਜਾਂਦੇ ਹਨ. ਸ਼ਾਇਦ ਇਸ ਲੇਖ ਦੇ ਪੂਰਾ ਹੋਣ ਤੱਕ ਇੱਕ ਨਵਾਂ ਸੰਸਕਰਣ ਜਾਰੀ ਕੀਤਾ ਜਾਵੇਗਾ। ਇਸ ਲਈ, ਪੜ੍ਹਨ ਤੋਂ ਪਹਿਲਾਂ, ਮੈਂ ਇਸ ਸਮੇਂ Nomad ਦੇ ਮੌਜੂਦਾ ਸੰਸਕਰਣ ਦੀ ਜਾਂਚ ਕਰਨ ਅਤੇ ਇਸਨੂੰ ਡਾਉਨਲੋਡ ਕਰਨ ਦੀ ਸਿਫਾਰਸ਼ ਕਰਦਾ ਹਾਂ.

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 ਵਿੱਚ ਤਬਦੀਲ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ।

ਆਓ Nomad ਲਈ ਇੱਕ ਡੇਟਾ ਡਾਇਰੈਕਟਰੀ ਬਣਾਈਏ ਅਤੇ ਇਸਦੀ ਸੇਵਾ ਫਾਈਲ ਨੂੰ ਸੰਪਾਦਿਤ ਕਰੀਏ (ਇਹ ਸੰਭਵ ਤੌਰ 'ਤੇ ਸ਼ੁਰੂ ਵਿੱਚ ਮੌਜੂਦ ਨਹੀਂ ਹੋਵੇਗੀ):

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. Nomad ਕਲੱਸਟਰ ਵਿੱਚ ਸਰਵਰਾਂ ਦੀ ਸੂਚੀ

ਦੋਵੇਂ ਸਰਵਰ ਸਫਲਤਾਪੂਰਵਕ ਪੈਨਲ ਵਿੱਚ ਪ੍ਰਦਰਸ਼ਿਤ ਕੀਤੇ ਗਏ ਹਨ, ਅਸੀਂ ਨੋਮਡ ਨੋਡ ਸਟੇਟਸ ਕਮਾਂਡ ਦੇ ਆਉਟਪੁੱਟ ਵਿੱਚ ਉਹੀ ਚੀਜ਼ ਵੇਖਾਂਗੇ:

ਚਿੱਤਰ 2. nomad node status ਕਮਾਂਡ ਦਾ ਆਉਟਪੁੱਟ

ਕੌਂਸਲ ਬਾਰੇ ਕੀ? ਆਓ ਇੱਕ ਨਜ਼ਰ ਮਾਰੀਏ। ਕੌਂਸਲ ਕੰਟਰੋਲ ਪੈਨਲ 'ਤੇ ਜਾਓ, ਨੋਡਸ ਪੰਨੇ 'ਤੇ:

ਚਿੱਤਰ 3. ਕੌਂਸਲ ਕਲੱਸਟਰ ਵਿੱਚ ਨੋਡਾਂ ਦੀ ਸੂਚੀ

ਹੁਣ ਸਾਡੇ ਕੋਲ ਕੌਂਸਲ ਦੇ ਨਾਲ ਮਿਲ ਕੇ ਕੰਮ ਕਰਨ ਵਾਲਾ ਇੱਕ ਤਿਆਰ ਨੋਮੈਡ ਹੈ। ਅੰਤਮ ਪੜਾਅ ਵਿੱਚ, ਅਸੀਂ ਮਜ਼ੇਦਾਰ ਹਿੱਸੇ 'ਤੇ ਪਹੁੰਚਾਂਗੇ: ਗਿਟਲੈਬ ਤੋਂ ਨੋਮੈਡ ਤੱਕ ਡੌਕਰ ਕੰਟੇਨਰਾਂ ਦੀ ਡਿਲਿਵਰੀ ਸਥਾਪਤ ਕਰਨਾ, ਅਤੇ ਇਸ ਦੀਆਂ ਕੁਝ ਹੋਰ ਵਿਲੱਖਣ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਬਾਰੇ ਵੀ ਗੱਲ ਕਰਨਾ।

ਗਿਟਲਬ ਰਨਰ ਬਣਾਉਣਾ

ਨੋਮੈਡ ਵਿੱਚ ਡੌਕਰ ਚਿੱਤਰਾਂ ਨੂੰ ਤੈਨਾਤ ਕਰਨ ਲਈ, ਅਸੀਂ ਅੰਦਰ ਨੋਮੈਡ ਬਾਈਨਰੀ ਫਾਈਲ ਦੇ ਨਾਲ ਇੱਕ ਵੱਖਰੇ ਰਨਰ ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ (ਇੱਥੇ, ਤਰੀਕੇ ਨਾਲ, ਅਸੀਂ ਹੈਸ਼ੀਕੋਰਪ ਐਪਲੀਕੇਸ਼ਨਾਂ ਦੀ ਇੱਕ ਹੋਰ ਵਿਸ਼ੇਸ਼ਤਾ ਨੂੰ ਨੋਟ ਕਰ ਸਕਦੇ ਹਾਂ - ਵਿਅਕਤੀਗਤ ਤੌਰ 'ਤੇ ਉਹ ਇੱਕ ਸਿੰਗਲ ਬਾਈਨਰੀ ਫਾਈਲ ਹਨ)। ਇਸਨੂੰ ਰਨਰ ਡਾਇਰੈਕਟਰੀ ਵਿੱਚ ਅੱਪਲੋਡ ਕਰੋ। ਆਓ ਹੇਠਾਂ ਦਿੱਤੀ ਸਮੱਗਰੀ ਦੇ ਨਾਲ ਇਸਦੇ ਲਈ ਇੱਕ ਸਧਾਰਨ ਡੌਕਰਫਾਈਲ ਬਣਾਈਏ:

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}

ਨਤੀਜੇ ਵਜੋਂ, ਸਾਡੇ ਕੋਲ ਗਿਟਲੈਬ ਰਜਿਸਟਰੀ ਵਿੱਚ ਨੋਮੈਡ ਦੌੜਾਕ ਦੀ ਇੱਕ ਉਪਲਬਧ ਤਸਵੀਰ ਹੋਵੇਗੀ, ਹੁਣ ਅਸੀਂ ਸਿੱਧੇ ਪ੍ਰੋਜੈਕਟ ਰਿਪੋਜ਼ਟਰੀ ਵਿੱਚ ਜਾ ਸਕਦੇ ਹਾਂ, ਇੱਕ ਪਾਈਪਲਾਈਨ ਬਣਾ ਸਕਦੇ ਹਾਂ ਅਤੇ ਨੋਮੈਡ ਦੀ ਨੋਮੈਡ ਜੌਬ ਨੂੰ ਕੌਂਫਿਗਰ ਕਰ ਸਕਦੇ ਹਾਂ।

ਪ੍ਰੋਜੈਕਟ ਸੈੱਟਅੱਪ

ਆਓ Nomad ਲਈ ਨੌਕਰੀ ਦੀ ਫਾਈਲ ਨਾਲ ਸ਼ੁਰੂਆਤ ਕਰੀਏ। ਇਸ ਲੇਖ ਵਿੱਚ ਮੇਰਾ ਪ੍ਰੋਜੈਕਟ ਕਾਫ਼ੀ ਮੁੱਢਲਾ ਹੋਵੇਗਾ: ਇਸ ਵਿੱਚ ਇੱਕ ਕੰਮ ਸ਼ਾਮਲ ਹੋਵੇਗਾ। .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" {}
                }
            }
        }
    }
}

ਕਿਰਪਾ ਕਰਕੇ ਨੋਟ ਕਰੋ ਕਿ ਮੇਰੇ ਕੋਲ ਇੱਕ ਪ੍ਰਾਈਵੇਟ ਰਜਿਸਟਰੀ ਹੈ ਅਤੇ ਇੱਕ ਡੌਕਰ ਚਿੱਤਰ ਨੂੰ ਸਫਲਤਾਪੂਰਵਕ ਖਿੱਚਣ ਲਈ ਮੈਨੂੰ ਇਸ ਵਿੱਚ ਲੌਗ ਇਨ ਕਰਨ ਦੀ ਲੋੜ ਹੈ। ਇਸ ਕੇਸ ਵਿੱਚ ਸਭ ਤੋਂ ਵਧੀਆ ਹੱਲ ਹੈ ਵਾਲਟ ਵਿੱਚ ਇੱਕ ਲੌਗਇਨ ਅਤੇ ਪਾਸਵਰਡ ਦਰਜ ਕਰਨਾ ਅਤੇ ਫਿਰ ਇਸਨੂੰ ਨੋਮੈਡ ਨਾਲ ਜੋੜਨਾ। Nomad ਮੂਲ ਰੂਪ ਵਿੱਚ ਵਾਲਟ ਦਾ ਸਮਰਥਨ ਕਰਦਾ ਹੈ। ਪਰ ਪਹਿਲਾਂ, ਆਓ ਵਾਲਟ ਵਿੱਚ ਨੋਮੈਡ ਲਈ ਲੋੜੀਂਦੀਆਂ ਨੀਤੀਆਂ ਨੂੰ ਸਥਾਪਿਤ ਕਰੀਏ; ਉਹਨਾਂ ਨੂੰ ਡਾਊਨਲੋਡ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ:

# 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
}

ਇਸ ਸਧਾਰਨ ਪਹੁੰਚ ਨਾਲ, ਤੁਸੀਂ ਨੋਮੈਡ ਕਲੱਸਟਰ ਨੂੰ ਕੰਟੇਨਰਾਂ ਦੀ ਡਿਲਿਵਰੀ ਨੂੰ ਕੌਂਫਿਗਰ ਕਰ ਸਕਦੇ ਹੋ ਅਤੇ ਭਵਿੱਖ ਵਿੱਚ ਇਸ ਨਾਲ ਕੰਮ ਕਰ ਸਕਦੇ ਹੋ। ਮੈਂ ਕਹਾਂਗਾ ਕਿ ਕੁਝ ਹੱਦ ਤੱਕ ਮੈਂ ਨੋਮੈਡ ਨਾਲ ਹਮਦਰਦੀ ਰੱਖਦਾ ਹਾਂ - ਇਹ ਛੋਟੇ ਪ੍ਰੋਜੈਕਟਾਂ ਲਈ ਵਧੇਰੇ ਢੁਕਵਾਂ ਹੈ ਜਿੱਥੇ ਕੁਬਰਨੇਟਸ ਵਾਧੂ ਜਟਿਲਤਾ ਦਾ ਕਾਰਨ ਬਣ ਸਕਦੇ ਹਨ ਅਤੇ ਇਸਦੀ ਪੂਰੀ ਸਮਰੱਥਾ ਦਾ ਅਹਿਸਾਸ ਨਹੀਂ ਕਰਨਗੇ. ਨਾਲ ਹੀ, Nomad ਸ਼ੁਰੂਆਤ ਕਰਨ ਵਾਲਿਆਂ ਲਈ ਸੰਪੂਰਨ ਹੈ-ਇਸ ਨੂੰ ਸਥਾਪਿਤ ਕਰਨਾ ਅਤੇ ਕੌਂਫਿਗਰ ਕਰਨਾ ਆਸਾਨ ਹੈ। ਹਾਲਾਂਕਿ, ਕੁਝ ਪ੍ਰੋਜੈਕਟਾਂ 'ਤੇ ਟੈਸਟ ਕਰਨ ਵੇਲੇ, ਮੈਨੂੰ ਇਸਦੇ ਸ਼ੁਰੂਆਤੀ ਸੰਸਕਰਣਾਂ ਵਿੱਚ ਇੱਕ ਸਮੱਸਿਆ ਆਉਂਦੀ ਹੈ - ਬਹੁਤ ਸਾਰੇ ਬੁਨਿਆਦੀ ਫੰਕਸ਼ਨ ਇੱਥੇ ਨਹੀਂ ਹਨ ਜਾਂ ਉਹ ਸਹੀ ਤਰ੍ਹਾਂ ਕੰਮ ਨਹੀਂ ਕਰਦੇ ਹਨ. ਹਾਲਾਂਕਿ, ਮੇਰਾ ਮੰਨਣਾ ਹੈ ਕਿ ਨੋਮੈਡ ਵਿਕਾਸ ਕਰਨਾ ਜਾਰੀ ਰੱਖੇਗਾ ਅਤੇ ਭਵਿੱਖ ਵਿੱਚ ਇਹ ਉਹਨਾਂ ਕਾਰਜਾਂ ਨੂੰ ਪ੍ਰਾਪਤ ਕਰੇਗਾ ਜੋ ਹਰ ਕਿਸੇ ਨੂੰ ਲੋੜੀਂਦੇ ਹਨ.

ਲੇਖਕ: ਇਲਿਆ ਐਂਡਰੀਵ, ਅਲੈਕਸੀ ਜ਼ਾਡਾਨ ਅਤੇ ਲਾਈਵ ਲੀਨਕਸ ਟੀਮ ਦੁਆਰਾ ਸੰਪਾਦਿਤ


ਸਰੋਤ: www.habr.com