ProHoster > blog > Utawala > Kuanzisha kikundi cha Nomad kwa kutumia Consul na kuunganisha na Gitlab

Kuanzisha kikundi cha Nomad kwa kutumia Consul na kuunganisha na Gitlab

Utangulizi

Hivi majuzi, umaarufu wa Kubernetes umekuwa ukikua kwa kasi - miradi zaidi na zaidi inaitekeleza. Nilitaka kugusa orchestrator kama Nomad: ni bora kwa miradi ambayo tayari inatumia masuluhisho mengine kutoka kwa HashiCorp, kwa mfano, Vault na Consul, na miradi yenyewe sio ngumu katika suala la miundombinu. Nyenzo hii itakuwa na maagizo ya kusakinisha Nomad, kuchanganya nodi mbili kwenye nguzo, pamoja na kuunganisha Nomad na Gitlab.

Kuanzisha kikundi cha Nomad kwa kutumia Consul na kuunganisha na Gitlab

benchi ya mtihani

Kidogo kuhusu benchi ya majaribio: seva tatu za kawaida hutumiwa na sifa za 2 CPU, 4 RAM, 50 Gb SSD, zimeunganishwa kwenye mtandao wa kawaida wa ndani. Majina yao na anwani za IP:

  1. nomad-livelinux-01: 172.30.0.5
  2. nomad-livelinux-02: 172.30.0.10
  3. balozi-livelinux-01: 172.30.0.15

Ufungaji wa Nomad, Balozi. Kuunda kikundi cha Nomad

Hebu tuanze na ufungaji wa msingi. Ingawa usanidi ulikuwa rahisi, nitaielezea kwa ajili ya uadilifu wa makala: kimsingi iliundwa kutoka kwa rasimu na madokezo kwa ufikiaji wa haraka inapohitajika.

Kabla ya kuanza mazoezi, tutajadili sehemu ya kinadharia, kwa sababu katika hatua hii ni muhimu kuelewa muundo wa baadaye.

Tuna nodi mbili za kuhamahama na tunataka kuzichanganya kuwa nguzo, na katika siku zijazo pia tutahitaji kuongeza kiotomatiki kwa nguzo - kwa hili tutahitaji Consul. Kwa chombo hiki, kuunganisha na kuongeza nodi mpya inakuwa kazi rahisi sana: nodi iliyoundwa ya Nomad inaunganisha kwa wakala wa Mshauri, na kisha inaunganisha kwenye nguzo iliyopo ya Nomad. Kwa hivyo, mwanzoni tutasakinisha seva ya Balozi, kusanidi idhini ya msingi ya http kwa paneli ya wavuti (haijaidhinishwa na chaguo-msingi na inaweza kupatikana kwa anwani ya nje), pamoja na mawakala wa Consul wenyewe kwenye seva za Nomad, baada ya hapo. tutaendelea tu kwa Nomad.

Kusakinisha zana za HashiCorp ni rahisi sana: kimsingi, tunahamisha faili ya jozi kwenye saraka ya pipa, kusanidi faili ya usanidi ya zana, na kuunda faili yake ya huduma.

Pakua faili ya binary ya Consul na uipakue kwenye saraka ya nyumbani ya mtumiaji:

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/

Sasa tunayo binary ya balozi iliyotengenezwa tayari kwa usanidi zaidi.

Ili kufanya kazi na Balozi, tunahitaji kuunda ufunguo wa kipekee kwa kutumia keygen amri:

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

Wacha tuendelee kusanidi usanidi wa Balozi, na kuunda saraka /etc/consul.d/ na muundo ufuatao:

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

Saraka ya bootstrap itakuwa na faili ya usanidi config.json - ndani yake tutaweka mipangilio ya Consul. Yaliyomo:

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

Wacha tuangalie maagizo kuu na maana zao kando:

  • bootstrap: kweli. Tunawezesha kuongeza kiotomatiki kwa nodi mpya ikiwa zimeunganishwa. Ninakumbuka kuwa hatuonyeshi hapa idadi kamili ya nodi zinazotarajiwa.
  • server: kweli. Washa hali ya seva. Balozi kwenye mashine hii pepe atafanya kama seva na bwana pekee kwa sasa, VM ya Nomad itakuwa wateja.
  • datacenter:dc1. Bainisha jina la kituo cha data ili kuunda kikundi. Lazima iwe sawa kwa wateja na seva.
  • encrypt: ufunguo wako. Ufunguo, ambao lazima pia uwe wa kipekee na ufanane na wateja na seva zote. Imetolewa kwa kutumia amri ya balozi keygen.
  • anza_jiunge. Katika orodha hii tunaonyesha orodha ya anwani za IP ambazo uunganisho utafanywa. Kwa sasa tunaacha tu anwani yetu wenyewe.

Katika hatua hii tunaweza kukimbia balozi kwa kutumia mstari wa amri:

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

Hii ni njia nzuri ya kutatua sasa, hata hivyo, hutaweza kutumia njia hii mara kwa mara kwa sababu za wazi. Wacha tuunde faili ya huduma ya kudhibiti Consul kupitia systemd:

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

Yaliyomo kwenye faili ya 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

Zindua Mshauri kupitia systemctl:

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

Wacha tuangalie: huduma yetu lazima iendeshe, na kwa kutekeleza amri ya wanachama wa balozi tunapaswa kuona seva yetu:

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

Hatua inayofuata: kusakinisha Nginx na kusanidi proksi na idhini ya http. Tunasanikisha nginx kupitia meneja wa kifurushi na kwenye saraka /etc/nginx/sites-enabled tunaunda faili ya usanidi consul.conf na yaliyomo yafuatayo:

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

Usisahau kuunda faili ya .htpasswd na kuzalisha jina la mtumiaji na nenosiri kwa hilo. Kipengee hiki kinahitajika ili paneli ya wavuti isipatikane kwa kila mtu anayejua kikoa chetu. Walakini, wakati wa kusanidi Gitlab, tutalazimika kuachana na hii - vinginevyo hatutaweza kupeleka ombi letu kwa Nomad. Katika mradi wangu, Gitlab na Nomad ziko kwenye wavuti ya kijivu tu, kwa hivyo hakuna shida kama hiyo hapa.

Kwenye seva mbili zilizobaki tunaweka mawakala wa Consul kulingana na maagizo yafuatayo. Tunarudia hatua na faili ya binary:

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/

Kwa mlinganisho na seva iliyopita, tunaunda saraka ya faili za usanidi /etc/consul.d na muundo ufuatao:

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

Yaliyomo kwenye faili ya 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
     }

Hifadhi mabadiliko na uendelee kusanidi faili ya huduma, yaliyomo:

/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

Tunazindua balozi kwenye seva. Sasa, baada ya uzinduzi, tunapaswa kuona huduma iliyosanidiwa katika washiriki wa nsul. Hii itamaanisha kuwa imeunganishwa kwa ufanisi kwenye nguzo kama mteja. Rudia sawa kwenye seva ya pili na baada ya hapo tunaweza kuanza kusanikisha na kusanidi Nomad.

Ufungaji wa kina zaidi wa Nomad umeelezewa katika nyaraka zake rasmi. Kuna njia mbili za usakinishaji wa jadi: kupakua faili ya binary na kuandaa kutoka kwa chanzo. Nitachagua njia ya kwanza.

Kumbuka: Mradi unaendelea haraka sana, sasisho mpya mara nyingi hutolewa. Labda toleo jipya litatolewa wakati makala hii itakamilika. Kwa hiyo, kabla ya kusoma, ninapendekeza kuangalia toleo la sasa la Nomad kwa sasa na kupakua. 

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

Baada ya kufungua, tutapokea faili ya binary ya Nomad yenye uzito wa MB 65 - lazima ihamishwe hadi /usr/local/bin.

Wacha tuunde saraka ya data kwa Nomad na kuhariri faili yake ya huduma (uwezekano mkubwa hautakuwepo mwanzoni):

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

Bandika mistari ifuatayo hapo:

[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

Walakini, hatuna haraka ya kuzindua nomad - bado hatujaunda faili yake ya usanidi:

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

Muundo wa saraka ya mwisho itakuwa kama ifuatavyo:

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

Faili ya nomad.hcl inapaswa kuwa na usanidi ufuatao:

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

Yaliyomo kwenye seva.hcl faili:

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
}

Usisahau kubadilisha faili ya usanidi kwenye seva ya pili - huko utahitaji kubadilisha thamani ya mwongozo wa http.

Jambo la mwisho katika hatua hii ni kusanidi Nginx kwa proksi na kusanidi idhini ya http. Yaliyomo kwenye faili ya 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";
        }
        
}

Sasa tunaweza kufikia paneli ya wavuti kupitia mtandao wa nje. Unganisha na uende kwenye ukurasa wa seva:

Kuanzisha kikundi cha Nomad kwa kutumia Consul na kuunganisha na Gitlab
Picha 1. Orodha ya seva katika nguzo ya Nomad

Seva zote mbili zinaonyeshwa kwa ufanisi kwenye paneli, tutaona kitu kimoja katika matokeo ya amri ya hali ya nodi ya nomad:

Kuanzisha kikundi cha Nomad kwa kutumia Consul na kuunganisha na Gitlab
Picha 2. Pato la amri ya hali ya nodi ya nomad

Vipi kuhusu Balozi? Hebu tuangalie. Nenda kwa paneli ya udhibiti ya Balozi, kwa ukurasa wa nodi:
Kuanzisha kikundi cha Nomad kwa kutumia Consul na kuunganisha na Gitlab
Picha 3. Orodha ya nodi katika nguzo ya Balozi

Sasa tuna Nomad iliyoandaliwa inayofanya kazi kwa kushirikiana na Balozi. Katika hatua ya mwisho, tutafika kwenye sehemu ya kufurahisha: kusanidi uwasilishaji wa vyombo vya Docker kutoka Gitlab hadi Nomad, na pia kuzungumza juu ya baadhi ya vipengele vyake vingine tofauti.

Kuunda Gitlab Runner

Ili kupeleka picha za docker kwa Nomad, tutatumia kikimbiaji tofauti na faili ya binary ya Nomad ndani (hapa, kwa njia, tunaweza kutambua kipengele kingine cha programu za Hashicorp - kibinafsi ni faili moja ya binary). Ipakie kwenye saraka ya kiendeshaji. Wacha tuunde Dockerfile rahisi kwake na yaliyomo yafuatayo:


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

Katika mradi huo huo tunaunda .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}

Kama matokeo, tutakuwa na picha inayopatikana ya mkimbiaji wa Nomad katika Usajili wa Gitlab, sasa tunaweza kwenda moja kwa moja kwenye hazina ya mradi, kuunda Bomba na kusanidi kazi ya nomad ya Nomad.

Mpangilio wa mradi

Wacha tuanze na faili ya kazi kwa Nomad. Mradi wangu katika nakala hii utakuwa wa zamani kabisa: itakuwa na kazi moja. Yaliyomo kwenye .gitlab-ci yatakuwa kama ifuatavyo:

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

Hapa kupelekwa hutokea kwa mikono, lakini unaweza kuisanidi ili kubadilisha yaliyomo kwenye saraka ya mradi. Bomba lina hatua mbili: mkusanyiko wa picha na kupelekwa kwake kwa nomad. Katika hatua ya kwanza, tunakusanya picha ya docker na kuisukuma kwenye Usajili wetu, na kwa pili tunazindua kazi yetu katika 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" {}
                }
            }
        }
    }
}

Tafadhali kumbuka kuwa nina Usajili wa kibinafsi na ili kuvuta picha ya kizimbani kwa mafanikio ninahitaji kuingia ndani yake. Suluhisho bora katika kesi hii ni kuingiza kuingia na nenosiri kwenye Vault na kisha kuiunganisha na Nomad. Nomad asili yake inasaidia Vault. Lakini kwanza, wacha tusakinishe sera zinazohitajika kwa Nomad kwenye Vault yenyewe; zinaweza kupakuliwa:

# 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

Sasa, baada ya kuunda sera zinazohitajika, tutaongeza ujumuishaji na Vault kwenye kizuizi cha kazi kwenye faili ya job.nomad:

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

Ninatumia idhini kwa ishara na kuisajili moja kwa moja hapa, pia kuna chaguo la kubainisha ishara kama kigezo wakati wa kuanza wakala wa nomad:

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

Sasa tunaweza kutumia funguo na Vault. Kanuni ya operesheni ni rahisi: tunaunda faili katika kazi ya Nomad ambayo itahifadhi maadili ya anuwai, kwa mfano:

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
}

Kwa mbinu hii rahisi, unaweza kusanidi uwasilishaji wa vyombo kwenye nguzo ya Nomad na ufanye kazi nayo katika siku zijazo. Nitasema kwamba kwa kiasi fulani ninahurumia Nomad - inafaa zaidi kwa miradi midogo ambapo Kubernetes inaweza kusababisha utata wa ziada na haitatambua uwezo wake kamili. Zaidi ya hayo, Nomad inafaa kwa wanaoanza—ni rahisi kusakinisha na kusanidi. Walakini, ninapojaribu kwenye miradi fulani, ninakutana na shida na matoleo yake ya mapema - kazi nyingi za kimsingi hazipo au hazifanyi kazi kwa usahihi. Walakini, ninaamini kuwa Nomad itaendelea kukuza na katika siku zijazo itapata kazi ambazo kila mtu anahitaji.

Mwandishi: Ilya Andreev, iliyohaririwa na Alexey Zhadan na timu ya Live Linux


Chanzo: mapenzi.com

Kuongeza maoni