ការដំឡើង Nomad cluster ដោយប្រើកុងស៊ុល និងរួមបញ្ចូលជាមួយ Gitlab

សេចក្តីណែនាំ

ថ្មីៗនេះ ប្រជាប្រិយភាពរបស់ Kubernetes កំពុងតែកើនឡើងយ៉ាងឆាប់រហ័ស គម្រោងកាន់តែច្រើនកំពុងអនុវត្តវា។ ខ្ញុំចង់ប៉ះអ្នកសំដែងដូចជា Nomad៖ វាល្អឥតខ្ចោះសម្រាប់គម្រោងដែលប្រើដំណោះស្រាយផ្សេងទៀតរួចហើយពី HashiCorp ឧទាហរណ៍ Vault និង Consul ហើយគម្រោងខ្លួនឯងមិនស្មុគស្មាញទាក់ទងនឹងហេដ្ឋារចនាសម្ព័ន្ធទេ។ សម្ភារៈនេះនឹងមានការណែនាំសម្រាប់ដំឡើង Nomad ដោយរួមបញ្ចូលគ្នានូវថ្នាំងពីរចូលទៅក្នុងចង្កោម ក៏ដូចជាការរួមបញ្ចូល Nomad ជាមួយ Gitlab ។

ឈរសាកល្បង

បន្តិចអំពីកៅអីសាកល្បង៖ ម៉ាស៊ីនមេនិម្មិតចំនួនបីត្រូវបានប្រើប្រាស់ជាមួយនឹងលក្ខណៈនៃស៊ីភីយូ 2, 4 RAM, 50 Gb SSD, រួបរួមចូលទៅក្នុងបណ្តាញមូលដ្ឋានទូទៅមួយ។ ឈ្មោះ និងអាសយដ្ឋាន IP របស់ពួកគេ៖

1. nomad-livelinux-01: 172.30.0.5
2. nomad-livelinux-02: 172.30.0.10
3. កុងស៊ុល-livelinux-01: 172.30.0.15

ការដំឡើង Nomad, Consul ។ ការបង្កើតក្រុម Nomad

ចូរចាប់ផ្តើមជាមួយនឹងការដំឡើងមូលដ្ឋាន។ ទោះបីជាការរៀបចំមានលក្ខណៈសាមញ្ញក៏ដោយ ខ្ញុំនឹងពណ៌នាអំពីវាសម្រាប់ភាពសុចរិតនៃអត្ថបទ៖ វាត្រូវបានបង្កើតឡើងយ៉ាងសំខាន់ពីសេចក្តីព្រាង និងកំណត់ចំណាំសម្រាប់ការចូលប្រើរហ័សនៅពេលចាំបាច់។

មុនពេលយើងចាប់ផ្តើមអនុវត្ត យើងនឹងពិភាក្សាផ្នែកទ្រឹស្តី ពីព្រោះនៅដំណាក់កាលនេះ វាមានសារៈសំខាន់ណាស់ក្នុងការយល់ដឹងអំពីរចនាសម្ព័ន្ធនាពេលអនាគត។

យើងមានថ្នាំងពីរ ហើយយើងចង់បញ្ចូលពួកវាទៅក្នុងចង្កោមមួយ ហើយនៅពេលអនាគត យើងក៏នឹងត្រូវការការធ្វើមាត្រដ្ឋានចង្កោមដោយស្វ័យប្រវត្តិផងដែរ - សម្រាប់បញ្ហានេះ យើងនឹងត្រូវការកុងស៊ុល។ ជាមួយនឹងឧបករណ៍នេះ ការដាក់ចង្កោម និងបន្ថែមថ្នាំងថ្មីក្លាយជាកិច្ចការដ៏សាមញ្ញបំផុត៖ ថ្នាំង Nomad ដែលបានបង្កើតភ្ជាប់ទៅភ្នាក់ងារកុងស៊ុល ហើយបន្ទាប់មកភ្ជាប់ទៅចង្កោម Nomad ដែលមានស្រាប់។ ដូច្នេះនៅដើមដំបូង យើងនឹងដំឡើងម៉ាស៊ីនមេកុងស៊ុល កំណត់រចនាសម្ព័ន្ធការអនុញ្ញាត http មូលដ្ឋានសម្រាប់បន្ទះបណ្តាញ (វាគ្មានការអនុញ្ញាតតាមលំនាំដើម ហើយអាចចូលប្រើបានតាមអាសយដ្ឋានខាងក្រៅ) ក៏ដូចជាភ្នាក់ងារកុងស៊ុលខ្លួនឯងនៅលើម៉ាស៊ីនមេ Nomad បន្ទាប់ពីនោះ យើងនឹងបន្តទៅ Nomad ប៉ុណ្ណោះ។

ការដំឡើងឧបករណ៍របស់ 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/

ឥឡូវនេះយើងមានកុងស៊ុលគោលពីរដែលត្រៀមរួចជាស្រេចសម្រាប់ការកំណត់រចនាសម្ព័ន្ធបន្ថែម។

ដើម្បីធ្វើការជាមួយកុងស៊ុល យើងត្រូវបង្កើតសោពិសេសមួយដោយប្រើពាក្យបញ្ជា keygen៖

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

ចូរបន្តទៅការរៀបចំការកំណត់កុងស៊ុល ដោយបង្កើតថតឯកសារ /etc/consul.d/ ដែលមានរចនាសម្ព័ន្ធដូចខាងក្រោម៖

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

ថត bootstrap នឹងមានឯកសារកំណត់រចនាសម្ព័ន្ធ 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"]
}

សូមក្រឡេកមើលការណែនាំសំខាន់ៗ និងអត្ថន័យរបស់វាដោយឡែកពីគ្នា៖

• bootstrap៖ ពិត។ យើងបើកការបន្ថែមថ្នាំងថ្មីដោយស្វ័យប្រវត្តិ ប្រសិនបើពួកវាត្រូវបានភ្ជាប់។ ខ្ញុំកត់សម្គាល់ថាយើងមិនចង្អុលបង្ហាញនៅទីនេះនូវចំនួនពិតប្រាកដនៃថ្នាំងដែលរំពឹងទុកនោះទេ។
• ម៉ាស៊ីនបម្រើ៖ ពិត។ បើករបៀបម៉ាស៊ីនមេ។ កុងស៊ុលនៅលើម៉ាស៊ីននិម្មិតនេះបច្ចុប្បន្ននឹងដើរតួជាម៉ាស៊ីនមេ និងមេតែមួយគត់ VM របស់ Nomad នឹងក្លាយជាអតិថិជន។
• មជ្ឈមណ្ឌល​ទិន្នន័យ៖ dc1 ។ បញ្ជាក់ឈ្មោះមជ្ឈមណ្ឌលទិន្នន័យដើម្បីបង្កើតចង្កោម។ វាត្រូវតែដូចគ្នាបេះបិទទាំងម៉ាស៊ីនភ្ញៀវ និងម៉ាស៊ីនមេ។
• អ៊ិនគ្រីប៖ កូនសោរបស់អ្នក។ គន្លឹះដែលត្រូវតែមានតែមួយគត់ និងត្រូវគ្នានៅលើម៉ាស៊ីនភ្ញៀវ និងម៉ាស៊ីនមេទាំងអស់។ បង្កើតដោយប្រើពាក្យបញ្ជាកុងស៊ុល keygen ។
• start_join. នៅក្នុងបញ្ជីនេះ យើងបង្ហាញបញ្ជីអាសយដ្ឋាន 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 បានទេ។ នៅក្នុងគម្រោងរបស់ខ្ញុំ ទាំង 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 ។ នេះនឹងមានន័យថាវាបានភ្ជាប់ដោយជោគជ័យទៅ cluster ជាម៉ាស៊ីនភ្ញៀវ។ ធ្វើម្តងទៀតដូចគ្នានៅលើម៉ាស៊ីនមេទីពីរ ហើយបន្ទាប់ពីនោះយើងអាចចាប់ផ្តើមដំឡើង និងកំណត់រចនាសម្ព័ន្ធ Nomad ។

ការដំឡើង 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

បន្ទាប់ពីការវេចខ្ចប់ យើងនឹងទទួលបានឯកសារគោលពីរ Nomad ដែលមានទម្ងន់ 65 MB - វាត្រូវតែផ្លាស់ទីទៅ /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

ទោះជាយ៉ាងណាក៏ដោយ យើងមិនប្រញាប់ប្រញាល់ក្នុងការបើកដំណើរការ nomad ទេ - យើងមិនទាន់បានបង្កើតឯកសារកំណត់រចនាសម្ព័ន្ធរបស់វានៅឡើយ៖

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 ។

រឿងចុងក្រោយនៅដំណាក់កាលនេះគឺកំណត់រចនាសម្ព័ន្ធ Nginx សម្រាប់ប្រូកស៊ី និងដំឡើងការអនុញ្ញាត http ។ ខ្លឹមសារនៃឯកសារ 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";
        }
        
}

ឥឡូវនេះយើងអាចចូលប្រើបន្ទះបណ្តាញតាមរយៈបណ្តាញខាងក្រៅ។ ភ្ជាប់ ហើយចូលទៅកាន់ទំព័រម៉ាស៊ីនមេ៖

រូបភាព ១. បញ្ជីម៉ាស៊ីនមេនៅក្នុងចង្កោម Nomad

ម៉ាស៊ីនមេទាំងពីរត្រូវបានបង្ហាញដោយជោគជ័យនៅក្នុងបន្ទះ យើងនឹងឃើញរឿងដូចគ្នានៅក្នុងលទ្ធផលនៃពាក្យបញ្ជាស្ថានភាព nomad nomad:

រូបភាព ១. លទ្ធផលនៃពាក្យបញ្ជាស្ថានភាពថ្នាំង nomad

ចុះកុងស៊ុលវិញ? តោះមើល។ ចូលទៅកាន់ផ្ទាំងបញ្ជាកុងស៊ុលទៅកាន់ទំព័រថ្នាំង៖

រូបភាព ១. បញ្ជីថ្នាំងនៅក្នុងចង្កោមកុងស៊ុល

ឥឡូវនេះ យើងមាន Nomad ដែលត្រៀមរួចជាស្រេច ដែលធ្វើការជាមួយកុងស៊ុល។ នៅដំណាក់កាលចុងក្រោយ យើងនឹងទៅដល់ផ្នែកដ៏រីករាយ៖ រៀបចំការដឹកជញ្ជូន Docker containers ពី Gitlab ទៅកាន់ Nomad ហើយក៏និយាយអំពីលក្ខណៈពិសេសប្លែកផ្សេងទៀតរបស់វាផងដែរ។

បង្កើត Gitlab Runner

ដើម្បីដាក់ពង្រាយរូបភាព docker ទៅ Nomad យើងនឹងប្រើកម្មវិធីរត់ដាច់ដោយឡែកដែលមានឯកសារគោលពីរ Nomad នៅខាងក្នុង (ដោយវិធីនេះ យើងអាចកត់សម្គាល់លក្ខណៈពិសេសផ្សេងទៀតនៃកម្មវិធី Hashicorp - ដាច់ដោយឡែកពីគ្នាវាជាឯកសារគោលពីរតែមួយ) ។ បង្ហោះវាទៅក្នុងបញ្ជីឈ្មោះអ្នករត់។ តោះបង្កើត Dockerfile សាមញ្ញមួយសម្រាប់វាជាមួយនឹងមាតិកាដូចខាងក្រោម៖

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 runner ដែលអាចរកបាននៅក្នុង Gitlab Registry ឥឡូវនេះយើងអាចទៅកាន់ឃ្លាំងគម្រោងដោយផ្ទាល់ បង្កើត Pipeline និងកំណត់រចនាសម្ព័ន្ធការងារ Nomad របស់ Nomad ។

ការរៀបចំគម្រោង

ចូរចាប់ផ្តើមជាមួយនឹងឯកសារការងារសម្រាប់ 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

នៅទីនេះការដាក់ពង្រាយកើតឡើងដោយដៃ ប៉ុន្តែអ្នកអាចកំណត់រចនាសម្ព័ន្ធវាដើម្បីផ្លាស់ប្តូរមាតិកានៃថតគម្រោង។ បំពង់បង្ហូរប្រេងមានពីរដំណាក់កាល៖ ការផ្គុំរូបភាព និងការដាក់ពង្រាយវាទៅមនុស្ស។ នៅដំណាក់កាលដំបូង យើងប្រមូលផ្តុំរូបភាព docker ហើយរុញវាចូលទៅក្នុង Registry របស់យើង ហើយនៅដំណាក់កាលទីពីរ យើងចាប់ផ្តើមការងាររបស់យើងនៅ Nomad ។

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

សូមចំណាំថា ខ្ញុំមាន Registry ឯកជនមួយ ហើយដើម្បីទាញយករូបភាព docker ដោយជោគជ័យ ខ្ញុំត្រូវចូលទៅវា។ ដំណោះស្រាយដ៏ល្អបំផុតក្នុងករណីនេះគឺបញ្ចូលការចូល និងពាក្យសម្ងាត់ទៅក្នុង Vault ហើយបន្ទាប់មកបញ្ចូលវាជាមួយ Nomad ។ Nomad មានដើមកំណើតគាំទ្រ Vault ។ ប៉ុន្តែជាដំបូង ចូរយើងដំឡើងគោលការណ៍ចាំបាច់សម្រាប់ Nomad នៅក្នុង Vault ខ្លួនវា ពួកគេអាចទាញយកបាន៖

# 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

ឥឡូវនេះ ដោយបានបង្កើតគោលការណ៍ចាំបាច់ យើងនឹងបន្ថែមការរួមបញ្ចូលជាមួយ Vault នៅក្នុងប្លុកកិច្ចការក្នុងឯកសារ job.nomad៖

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

ខ្ញុំប្រើការអនុញ្ញាតដោយសញ្ញាសម្ងាត់ ហើយចុះឈ្មោះវាដោយផ្ទាល់នៅទីនេះ វាក៏មានជម្រើសនៃការបញ្ជាក់សញ្ញាសម្ងាត់ជាអថេរនៅពេលចាប់ផ្តើមភ្នាក់ងារ nomad៖

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

ឥឡូវនេះយើងអាចប្រើសោជាមួយ Vault ។ គោលការណ៍នៃប្រតិបត្តិការគឺសាមញ្ញ៖ យើងបង្កើតឯកសារមួយនៅក្នុងការងារ Nomad ដែលនឹងរក្សាទុកតម្លៃនៃអថេរឧទាហរណ៍៖

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 ហើយធ្វើការជាមួយវានាពេលអនាគត។ ខ្ញុំនឹងនិយាយថាក្នុងកម្រិតណាមួយដែលខ្ញុំអាណិត Nomad - វាកាន់តែសមស្របសម្រាប់គម្រោងតូចៗដែល Kubernetes អាចបង្កឱ្យមានភាពស្មុគស្មាញបន្ថែម ហើយនឹងមិនដឹងពីសក្តានុពលពេញលេញរបស់វា។ លើសពីនេះ Nomad គឺល្អឥតខ្ចោះសម្រាប់អ្នកចាប់ផ្តើមដំបូង ងាយស្រួលដំឡើង និងកំណត់រចនាសម្ព័ន្ធ។ ទោះជាយ៉ាងណាក៏ដោយ នៅពេលសាកល្បងលើគម្រោងមួយចំនួន ខ្ញុំជួបប្រទះបញ្ហាជាមួយនឹងកំណែដំបូងរបស់វា - មុខងារជាមូលដ្ឋានជាច្រើនមិនមាននៅទីនោះ ឬវាមិនដំណើរការត្រឹមត្រូវ។ ទោះជាយ៉ាងណាក៏ដោយ ខ្ញុំជឿជាក់ថា Nomad នឹងបន្តអភិវឌ្ឍ ហើយនៅពេលអនាគត វានឹងទទួលបាននូវមុខងារដែលមនុស្សគ្រប់គ្នាត្រូវការ។

អ្នកនិពន្ធ៖ Ilya Andreev កែសម្រួលដោយ Alexey Zhadan និងក្រុម Live Linux


ប្រភព: www.habr.com