కాన్సుల్‌ని ఉపయోగించి నోమాడ్ క్లస్టర్‌ను ఏర్పాటు చేయడం మరియు గిట్‌లాబ్‌తో అనుసంధానం చేయడం

పరిచయం

ఇటీవల, కుబెర్నెట్స్ యొక్క ప్రజాదరణ వేగంగా పెరుగుతోంది - మరిన్ని ప్రాజెక్టులు దీనిని అమలు చేస్తున్నాయి. నేను నోమాడ్ వంటి ఆర్కెస్ట్రేటర్‌ను తాకాలనుకుంటున్నాను: ఇది ఇప్పటికే 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

నోమాడ్, కాన్సుల్ యొక్క సంస్థాపన. నోమాడ్ క్లస్టర్‌ను సృష్టిస్తోంది

ప్రాథమిక సంస్థాపనతో ప్రారంభిద్దాం. సెటప్ సరళమైనది అయినప్పటికీ, వ్యాసం యొక్క సమగ్రత కొరకు నేను దానిని వివరిస్తాను: ఇది తప్పనిసరిగా అవసరమైనప్పుడు త్వరిత ప్రాప్యత కోసం చిత్తుప్రతులు మరియు గమనికల నుండి సృష్టించబడింది.

మేము అభ్యాసాన్ని ప్రారంభించే ముందు, మేము సైద్ధాంతిక భాగాన్ని చర్చిస్తాము, ఎందుకంటే ఈ దశలో భవిష్యత్తు నిర్మాణాన్ని అర్థం చేసుకోవడం చాలా ముఖ్యం.

మాకు రెండు నోమాడ్ నోడ్‌లు ఉన్నాయి మరియు మేము వాటిని క్లస్టర్‌గా కలపాలనుకుంటున్నాము మరియు భవిష్యత్తులో మనకు ఆటోమేటిక్ క్లస్టర్ స్కేలింగ్ కూడా అవసరం - దీని కోసం మాకు కాన్సుల్ అవసరం. ఈ సాధనంతో, కొత్త నోడ్‌లను క్లస్టరింగ్ చేయడం మరియు జోడించడం చాలా సులభమైన పని అవుతుంది: సృష్టించిన నోమాడ్ నోడ్ కాన్సుల్ ఏజెంట్‌కి కనెక్ట్ అవుతుంది, ఆపై ఇప్పటికే ఉన్న నోమాడ్ క్లస్టర్‌కి కనెక్ట్ అవుతుంది. అందువల్ల, ప్రారంభంలో మేము కాన్సుల్ సర్వర్‌ను ఇన్‌స్టాల్ చేస్తాము, వెబ్ ప్యానెల్ కోసం ప్రాథమిక 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 క్లయింట్‌లుగా ఉంటారు.
• datacenter: 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 మరియు 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 సభ్యులలో కాన్ఫిగర్ చేయబడిన సేవను చూడాలి. ఇది క్లయింట్‌గా క్లస్టర్‌కి విజయవంతంగా కనెక్ట్ చేయబడిందని దీని అర్థం. రెండవ సర్వర్‌లో అదే పునరావృతం చేయండి మరియు ఆ తర్వాత మేము నోమాడ్‌ను ఇన్‌స్టాల్ చేయడం మరియు కాన్ఫిగర్ చేయడం ప్రారంభించవచ్చు.

నోమాడ్ యొక్క మరింత వివరణాత్మక సంస్థాపన దాని అధికారిక డాక్యుమెంటేషన్‌లో వివరించబడింది. రెండు సాంప్రదాయ సంస్థాపనా పద్ధతులు ఉన్నాయి: బైనరీ ఫైల్‌ను డౌన్‌లోడ్ చేయడం మరియు మూలం నుండి కంపైల్ చేయడం. నేను మొదటి పద్ధతిని ఎంచుకుంటాను.

వ్యాఖ్య: ప్రాజెక్ట్ చాలా త్వరగా అభివృద్ధి చెందుతోంది, కొత్త నవీకరణలు తరచుగా విడుదల చేయబడతాయి. ఈ కథనం పూర్తయ్యే సమయానికి బహుశా కొత్త వెర్షన్ విడుదల చేయబడవచ్చు. అందువల్ల, చదివే ముందు, ప్రస్తుతానికి నోమాడ్ యొక్క ప్రస్తుత సంస్కరణను తనిఖీ చేసి, దానిని డౌన్‌లోడ్ చేయమని నేను సిఫార్సు చేస్తున్నాను.

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 బరువుతో నోమాడ్ బైనరీ ఫైల్‌ని అందుకుంటాము - ఇది తప్పనిసరిగా /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