ProHoster > blog > administrasi > Menyiapkan cluster Nomad menggunakan Konsul dan mengintegrasikan dengan Gitlab

Menyiapkan cluster Nomad menggunakan Konsul dan mengintegrasikan dengan Gitlab

pengenalan

Baru-baru ini, popularitas Kubernetes berkembang pesat - semakin banyak proyek yang mengimplementasikannya. Saya ingin menyentuh orkestrator seperti Nomad: ini sempurna untuk proyek yang sudah menggunakan solusi lain dari HashiCorp, misalnya Vault dan Konsul, dan proyeknya sendiri tidak rumit dari segi infrastruktur. Materi ini akan berisi instruksi untuk menginstal Nomad, menggabungkan dua node menjadi satu cluster, serta mengintegrasikan Nomad dengan Gitlab.

Menyiapkan cluster Nomad menggunakan Konsul dan mengintegrasikan dengan Gitlab

Tempat uji coba

Sedikit tentang bangku tes: tiga server virtual digunakan dengan karakteristik 2 CPU, 4 RAM, 50 Gb SSD, digabungkan menjadi jaringan lokal yang sama. Nama dan alamat IP mereka:

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

Pemasangan Nomad, Konsul. Membuat cluster Nomad

Mari kita mulai dengan instalasi dasar. Meskipun pengaturannya sederhana, saya akan menjelaskannya demi integritas artikel: pada dasarnya ini dibuat dari draf dan catatan untuk akses cepat bila diperlukan.

Sebelum kita mulai praktek, kita akan membahas bagian teorinya, karena pada tahap ini penting untuk memahami struktur masa depan.

Kami memiliki dua node nomad dan kami ingin menggabungkannya ke dalam sebuah cluster, dan di masa depan kami juga memerlukan penskalaan cluster otomatis - untuk ini kami memerlukan Konsul. Dengan alat ini, pengelompokan dan penambahan node baru menjadi tugas yang sangat sederhana: node Nomad yang dibuat terhubung ke agen Konsul, dan kemudian terhubung ke cluster Nomad yang ada. Oleh karena itu, pertama-tama kita akan menginstal server Konsul, mengkonfigurasi otorisasi http dasar untuk panel web (tanpa otorisasi secara default dan dapat diakses di alamat eksternal), serta agen Konsul itu sendiri di server Nomad, setelah itu yang kami hanya akan melanjutkan ke Nomad.

Menginstal alat HashiCorp sangat sederhana: pada dasarnya, kita hanya memindahkan file biner ke direktori bin, menyiapkan file konfigurasi alat, dan membuat file layanannya.

Unduh file biner Konsul dan ekstrak ke direktori home pengguna:

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/

Sekarang kami memiliki biner konsul yang siap pakai untuk konfigurasi lebih lanjut.

Untuk bekerja dengan Konsul, kita perlu membuat kunci unik menggunakan perintah keygen:

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

Mari kita lanjutkan ke pengaturan konfigurasi Konsul, membuat direktori /etc/consul.d/ dengan struktur berikut:

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

Direktori bootstrap akan berisi file konfigurasi config.json - di dalamnya kita akan mengatur pengaturan Konsul. Isinya:

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

Mari kita lihat arahan utama dan artinya secara terpisah:

  • bootstrap: BENAR. Kami mengaktifkan penambahan otomatis node baru jika terhubung. Saya perhatikan bahwa kami tidak menunjukkan di sini jumlah pasti node yang diharapkan.
  • Server: BENAR. Aktifkan mode server. Konsul pada mesin virtual ini akan bertindak sebagai satu-satunya server dan master saat ini, VM Nomad akan menjadi kliennya.
  • Pusat Data: dc1. Tentukan nama pusat data untuk membuat cluster. Itu harus identik pada klien dan server.
  • mengenkripsi: kunci MU. Kuncinya juga harus unik dan cocok di semua klien dan server. Dihasilkan menggunakan perintah konsul keygen.
  • mulai_bergabung. Dalam daftar ini kami menunjukkan daftar alamat IP yang akan dibuat koneksinya. Saat ini kami hanya meninggalkan alamat kami sendiri.

Pada titik ini kita dapat menjalankan konsul menggunakan baris perintah:

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

Ini adalah cara yang baik untuk melakukan debug sekarang, namun Anda tidak akan dapat menggunakan metode ini terus-menerus karena alasan yang jelas. Mari buat file layanan untuk mengelola Konsul melalui systemd:

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

Isi file 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

Luncurkan Konsul melalui systemctl:

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

Mari kita periksa: layanan kita harus berjalan, dan dengan menjalankan perintah consul member kita akan melihat server kita:

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

Tahap selanjutnya: menginstal Nginx dan mengatur proxy dan otorisasi http. Kita install nginx melalui package manager dan di direktori /etc/nginx/sites-enabled kita membuat file konfigurasi consul.conf dengan isi sebagai berikut:

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

Jangan lupa untuk membuat file .htpasswd dan menghasilkan nama pengguna dan kata sandi untuk itu. Item ini diperlukan agar panel web tidak tersedia untuk semua orang yang mengetahui domain kami. Namun, saat menyiapkan Gitlab, kami harus mengabaikannya - jika tidak, kami tidak akan dapat menerapkan aplikasi kami ke Nomad. Dalam proyek saya, baik Gitlab dan Nomad hanya ada di web abu-abu, jadi tidak ada masalah seperti itu di sini.

Di dua server tersisa kami menginstal agen Konsul sesuai dengan instruksi berikut. Kami mengulangi langkah-langkah dengan file biner:

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/

Mirip dengan server sebelumnya, kita membuat direktori untuk file konfigurasi /etc/consul.d dengan struktur sebagai berikut:

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

Isi file 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
     }

Simpan perubahan dan lanjutkan ke pengaturan file layanan, isinya:

/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

Kami meluncurkan konsul di server. Sekarang, setelah peluncuran, kita akan melihat layanan yang dikonfigurasi di anggota nsul. Ini berarti telah berhasil terhubung ke cluster sebagai klien. Ulangi hal yang sama pada server kedua dan setelah itu kita dapat mulai menginstal dan mengkonfigurasi Nomad.

Instalasi Nomad yang lebih rinci dijelaskan dalam dokumentasi resminya. Ada dua metode instalasi tradisional: mengunduh file biner dan mengkompilasi dari sumber. Saya akan memilih metode pertama.

Catatan: Proyek ini berkembang sangat cepat, pembaruan baru sering kali dirilis. Mungkin versi baru akan dirilis pada saat artikel ini selesai. Oleh karena itu, sebelum membaca, saya sarankan untuk memeriksa versi Nomad saat ini dan mengunduhnya. 

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

Setelah dibongkar, kita akan menerima file biner Nomad dengan berat 65 MB - harus dipindahkan ke /usr/local/bin.

Mari buat direktori data untuk Nomad dan edit file layanannya (kemungkinan besar tidak akan ada di awal):

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

Rekatkan baris berikut di sana:

[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

Namun, kami tidak terburu-buru meluncurkan nomad - kami belum membuat file konfigurasinya:

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

Struktur direktori terakhir adalah sebagai berikut:

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

File nomad.hcl harus berisi konfigurasi berikut:

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

Isi file 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
}

Jangan lupa untuk mengubah file konfigurasi di server kedua - di sana Anda perlu mengubah nilai direktif http.

Hal terakhir pada tahap ini adalah mengkonfigurasi Nginx untuk proxy dan mengatur otorisasi http. Isi file 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";
        }
        
}

Sekarang kita dapat mengakses panel web melalui jaringan eksternal. Hubungkan dan buka halaman server:

Menyiapkan cluster Nomad menggunakan Konsul dan mengintegrasikan dengan Gitlab
Gambar 1. Daftar server di cluster Nomad

Kedua server berhasil ditampilkan di panel, kita akan melihat hal yang sama pada output perintah status node nomad:

Menyiapkan cluster Nomad menggunakan Konsul dan mengintegrasikan dengan Gitlab
Gambar 2. Output dari perintah status simpul nomad

Bagaimana dengan Konsul? Mari kita lihat. Buka panel kontrol Konsul, ke halaman node:
Menyiapkan cluster Nomad menggunakan Konsul dan mengintegrasikan dengan Gitlab
Gambar 3. Daftar node di cluster Konsul

Sekarang kami telah menyiapkan Nomad yang bekerja sama dengan Konsul. Pada tahap terakhir, kita akan sampai pada bagian yang menyenangkan: menyiapkan pengiriman container Docker dari Gitlab ke Nomad, dan juga membicarakan beberapa fitur khas lainnya.

Membuat Pelari Gitlab

Untuk menyebarkan gambar buruh pelabuhan ke Nomad, kita akan menggunakan runner terpisah dengan file biner Nomad di dalamnya (di sini, omong-omong, kita dapat mencatat fitur lain dari aplikasi Hashicorp - secara individual mereka adalah file biner tunggal). Unggah ke direktori runner. Mari buat Dockerfile sederhana dengan konten berikut:


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

Dalam proyek yang sama kami membuat .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}

Hasilnya, kita akan memiliki gambar pelari Nomad yang tersedia di Gitlab Registry, sekarang kita dapat langsung menuju ke repositori proyek, membuat Pipeline, dan mengonfigurasi pekerjaan nomad Nomad.

Pengaturan proyek

Mari kita mulai dengan file pekerjaan untuk Nomad. Proyek saya di artikel ini cukup primitif: terdiri dari satu tugas. Isi .gitlab-ci adalah sebagai berikut:

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

Di sini penerapan terjadi secara manual, tetapi Anda dapat mengonfigurasinya untuk mengubah konten direktori proyek. Pipeline terdiri dari dua tahap: perakitan gambar dan penerapannya ke nomad. Pada tahap pertama, kami merakit image buruh pelabuhan dan memasukkannya ke dalam Registry kami, dan pada tahap kedua kami meluncurkan pekerjaan kami di 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" {}
                }
            }
        }
    }
}

Harap dicatat bahwa saya memiliki Registry pribadi dan agar berhasil menarik gambar buruh pelabuhan saya harus masuk ke dalamnya. Solusi terbaik dalam hal ini adalah memasukkan login dan kata sandi ke Vault lalu mengintegrasikannya dengan Nomad. Nomad secara asli mendukung Vault. Namun pertama-tama, mari kita instal kebijakan yang diperlukan untuk Nomad di Vault itu sendiri; kebijakan tersebut dapat diunduh:

# 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

Sekarang, setelah membuat kebijakan yang diperlukan, kami akan menambahkan integrasi dengan Vault di blok tugas di file job.nomad:

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

Saya menggunakan otorisasi dengan token dan mendaftarkannya langsung di sini, ada juga opsi untuk menentukan token sebagai variabel saat memulai agen nomad:

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

Sekarang kita dapat menggunakan kunci dengan Vault. Prinsip pengoperasiannya sederhana: kita membuat file di pekerjaan Nomad yang akan menyimpan nilai variabel, misalnya:

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
}

Dengan pendekatan sederhana ini, Anda dapat mengonfigurasi pengiriman kontainer ke cluster Nomad dan bekerja dengannya di masa mendatang. Saya akan mengatakan bahwa sampai batas tertentu saya bersimpati dengan Nomad - ini lebih cocok untuk proyek kecil di mana Kubernetes dapat menyebabkan kompleksitas tambahan dan tidak akan mewujudkan potensi penuhnya. Selain itu, Nomad sangat cocok untuk pemula—mudah dipasang dan dikonfigurasi. Namun, saat menguji beberapa proyek, saya menemui masalah dengan versi awalnya - banyak fungsi dasar yang tidak ada atau tidak berfungsi dengan benar. Namun, saya yakin Nomad akan terus berkembang dan kedepannya akan memperoleh fungsi yang dibutuhkan semua orang.

Penulis: Ilya Andreev, diedit oleh Alexei Zhadan dan tim Live Linux


Sumber: www.habr.com

Tambah komentar