SaltStack - Panduan Cepat

Dalam bab ini, kita akan mempelajari dasar-dasar SaltStack. Kemampuan eksekusi jarak jauh SaltStack memungkinkan administrator menjalankan perintah pada berbagai mesin secara paralel dengan sistem penargetan yang fleksibel. Manajemen konfigurasi Salt menetapkan model master-minion untuk membawa komponen infrastruktur dengan cepat, sangat mudah, fleksibel, dan aman sejalan dengan kebijakan yang diberikan.

Apa itu SaltStack?

Garam adalah kerangka kerja otomatisasi yang sangat kuat. Arsitektur Salt didasarkan pada gagasan menjalankan perintah dari jarak jauh. Semua jaringan dirancang berdasarkan beberapa aspek eksekusi jarak jauh. Ini bisa sesederhana menanyakan aRemote Web Serveruntuk menampilkan halaman Web statis, atau serumit menggunakan sesi shell untuk mengeluarkan perintah secara interaktif terhadap server jarak jauh. Salt adalah contoh salah satu jenis eksekusi jarak jauh yang lebih kompleks.

Salt dirancang untuk memungkinkan pengguna secara eksplisit menargetkan dan mengeluarkan perintah ke beberapa mesin secara langsung. Garam didasarkan pada gagasan seorang Guru, yang mengontrol satu atau lebihMinions. Perintah biasanya dikeluarkan dari Master ke grup target Minion, yang kemudian menjalankan tugas yang ditentukan dalam perintah dan kemudian mengembalikan data yang dihasilkan kembali ke Master. Komunikasi antara master dan antek terjadi selamaZeroMQ message bus.

Modul SaltStack berkomunikasi dengan sistem operasi minion yang didukung. ItuSalt Masterberjalan di Linux secara default, tetapi sistem operasi apa pun bisa menjadi antek, dan saat ini varian Windows, VMware vSphere dan BSD Unix didukung dengan baik. Salt Master dan minion menggunakan kunci untuk berkomunikasi. Saat minion terhubung ke master untuk pertama kalinya, secara otomatis menyimpan kunci pada master. SaltStack juga menawarkanSalt SSH, yang menyediakan manajemen sistem "tanpa agen".

Kebutuhan SaltStack

SaltStack dibuat untuk kecepatan dan skala. Inilah sebabnya mengapa digunakan untuk mengelola infrastruktur besar dengan puluhan ribu server di LinkedIn, WikiMedia, dan Google.

Bayangkan Anda memiliki banyak server dan ingin melakukan sesuatu ke server tersebut. Anda perlu masuk ke masing-masing dan melakukan hal-hal itu satu per satu pada masing-masing dan kemudian Anda mungkin ingin melakukan hal-hal rumit seperti menginstal perangkat lunak dan kemudian mengkonfigurasi perangkat lunak itu berdasarkan beberapa kriteria tertentu.

Anggaplah Anda memiliki sepuluh atau bahkan 100 server. Bayangkan masuk satu per satu ke setiap server secara individu, mengeluarkan perintah yang sama pada 100 mesin tersebut dan kemudian mengedit file konfigurasi pada semua 100 mesin menjadi tugas yang sangat membosankan. Untuk mengatasi masalah tersebut, Anda ingin memperbarui semua server Anda sekaligus, hanya dengan mengetik satu perintah. SaltStack memberi Anda solusi yang tepat untuk semua masalah tersebut.

Fitur SaltStack

SaltStack adalah perangkat lunak manajemen konfigurasi sumber terbuka dan mesin eksekusi jarak jauh. Salt adalah alat baris perintah. Saat ditulis dengan Python, manajemen konfigurasi SaltStack adalah bahasa agnostik dan sederhana. Platform Salt menggunakan model push untuk menjalankan perintah melalui protokol SSH. Sistem konfigurasi default adalahYAML dan Jinja templates. Garam terutama bersaing denganPuppet, Chef dan Ansible.

Salt menyediakan banyak fitur jika dibandingkan dengan alat pesaing lainnya. Beberapa fitur penting ini tercantum di bawah ini.

Fault tolerance- Salt minion dapat terhubung ke beberapa master sekaligus dengan mengonfigurasi parameter konfigurasi master sebagai daftar YAML dari semua master yang tersedia. Setiap master dapat mengarahkan perintah ke infrastruktur Salt.
Flexible- Pendekatan seluruh manajemen Salt sangat fleksibel. Ini dapat diterapkan untuk mengikuti model manajemen sistem yang paling populer seperti Agen dan Server, Agen-saja, Server-saja atau semua yang di atas dalam lingkungan yang sama.
Scalable Configuration Management - SaltStack dirancang untuk menangani sepuluh ribu antek per master.
Parallel Execution model - Salt dapat mengaktifkan perintah untuk menjalankan sistem jarak jauh secara paralel.
Python API - Salt menyediakan antarmuka pemrograman yang sederhana dan dirancang untuk menjadi modular dan mudah diperluas, agar mudah dibentuk ke berbagai aplikasi.
Easy to Setup - Salt mudah diatur dan menyediakan arsitektur eksekusi jarak jauh tunggal yang dapat mengelola beragam persyaratan dari sejumlah server.
Language Agnostic - File konfigurasi keadaan garam, mesin template atau jenis file mendukung semua jenis bahasa.

Manfaat SaltStack

Sederhana dan kaya fitur, Salt memberikan banyak manfaat dan dapat diringkas seperti di bawah ini -

Robust - Salt adalah kerangka kerja manajemen konfigurasi yang kuat dan kuat dan bekerja di sekitar puluhan ribu sistem.
Authentication - Salt mengelola pasangan kunci SSH sederhana untuk otentikasi.
Secure - Salt mengelola data aman menggunakan protokol terenkripsi.
Fast - Salt adalah bus komunikasi yang sangat cepat dan ringan untuk memberikan fondasi bagi mesin eksekusi jarak jauh.
Virtual Machine Automation - Kemampuan Salt Virt Cloud Controller digunakan untuk otomatisasi.
Infrastructure as data, not code - Salt menyediakan penerapan sederhana, manajemen konfigurasi berbasis model, dan kerangka kerja eksekusi perintah.

Pengantar ZeroMQ

Salt didasarkan pada ZeroMQperpustakaan dan merupakan perpustakaan jaringan yang dapat disematkan. Ini ringan dan perpustakaan perpesanan cepat. Implementasi dasarnya ada diC/C++ dan implementasi asli untuk beberapa bahasa termasuk Java dan .Net tersedia.

ZeroMQ adalah pemrosesan pesan peer-peer tanpa broker. ZeroMQ memungkinkan Anda merancang sistem komunikasi yang kompleks dengan mudah.

ZeroMQ hadir dengan lima pola dasar berikut -

Synchronous Request/Response - Digunakan untuk mengirim permintaan dan menerima balasan berikutnya untuk setiap yang dikirim.
Asynchronous Request/Response- Pemohon memulai percakapan dengan mengirim pesan Permintaan dan menunggu pesan Respon. Penyedia menunggu pesan Permintaan masuk dan membalas dengan pesan Respon.
Publish/Subscribe - Digunakan untuk mendistribusikan data dari satu proses (misalnya penerbit) ke beberapa penerima (misalnya pelanggan).
Push/Pull - Digunakan untuk mendistribusikan data ke node yang terhubung.
Exclusive Pair - Digunakan untuk menghubungkan dua rekan bersama, membentuk pasangan.

ZeroMQ adalah alat jaringan yang sangat fleksibel untuk bertukar pesan antara cluster, cloud, dan lingkungan multi sistem lainnya. ZeroMQ adalahdefault transport library disajikan di SaltStack.

Arsitektur SaltStack dirancang untuk bekerja dengan sejumlah server, dari sistem jaringan lokal hingga penerapan lain di berbagai pusat data. Arsitektur adalah model server / klien sederhana dengan fungsionalitas yang dibutuhkan dibangun ke dalam satu set daemon.

Perhatikan ilustrasi berikut. Ini menunjukkan berbagai komponen arsitektur SaltStack.

SaltMaster- SaltMaster adalah daemon master. SaltMaster digunakan untuk mengirim perintah dan konfigurasi ke budak Salt. Seorang master tunggal dapat mengelola banyak master.
SaltMinions- SaltMinion adalah daemon budak. Minion Salt menerima perintah dan konfigurasi dari SaltMaster.
Execution- Modul dan perintah Adhoc dijalankan dari baris perintah terhadap satu atau lebih antek. Itu melakukan Pemantauan Real-time.
Formulas- Rumusnya adalah Salt States yang telah ditulis sebelumnya. Mereka terbuka seperti Salt States itu sendiri dan dapat digunakan untuk tugas-tugas seperti menginstal paket, mengkonfigurasi dan memulai layanan, mengatur pengguna atau izin dan banyak tugas umum lainnya.
Grains- Grains adalah antarmuka yang memberikan informasi khusus untuk antek. Informasi yang tersedia melalui antarmuka butir bersifat statis. Butir dimuat saat antek Salt dimulai. Ini berarti informasi dalam biji-bijian tidak berubah. Oleh karena itu, informasi butiran dapat berupa kernel yang sedang berjalan atau sistem operasi. Ini tidak membedakan huruf besar / kecil.
Pillar- Pilar adalah antarmuka yang menghasilkan dan menyimpan data yang sangat sensitif khusus untuk antek tertentu, seperti kunci kriptografi dan kata sandi. Ini menyimpan data dalam pasangan kunci / nilai dan data dikelola dengan cara yang sama seperti Salt State Tree.
Top File - Mencocokkan status Salt dan data pilar dengan minion Salt.
Runners - Ini adalah modul yang terletak di dalam SaltMaster dan melakukan tugas-tugas seperti status pekerjaan, status koneksi, membaca data dari API eksternal, meminta permintaan garam minion yang terhubung, dan banyak lagi.
Returners - Mengembalikan data dari minion Salt ke sistem lain.
Reactor - Bertanggung jawab untuk memicu reaksi saat peristiwa terjadi di lingkungan SaltStack Anda.
SaltCloud - Salt Cloud menyediakan antarmuka yang kuat untuk berinteraksi dengan host cloud.
SaltSSH - Jalankan perintah Salt melalui SSH pada sistem tanpa menggunakan minion Salt.

Di bab selanjutnya, kita akan mempelajari secara mendetail tentang berbagai pesaing SaltStack dan fitur-fiturnya.

Salt, Puppet, Chef, dan Ansible adalah alat manajemen konfigurasi dan orkestrasi terkemuka, yang masing-masing menggunakan jalur berbeda ke otomatisasi server. Mereka dibangun untuk memudahkan konfigurasi dan pemeliharaan lusinan, ratusan atau bahkan ribuan server.

Mari kita pahami bagaimana SaltStack bersaing terutama dengan Puppet, Chef, dan Ansible.

Platform dan Dukungan

Berikut adalah daftar semua platform yang mendukung SaltStack dan pesaingnya.

SaltStack - Software SaltStack berjalan dan mengelola banyak versi Linux, Windows, Mac OS X dan UNIX.
Puppet - Red Hat Enterprise Linux, CentOS, Oracle Linux, Scientific Linux, SUSE Linux Enterprise Server, dan Ubuntu.
Chef - Chef didukung pada berbagai platform seperti AIX, RHEL / CentOS, FreeBSD, OS X, Solaris, Microsoft Windows dan Ubuntu.
Ansible - Distribusi Fedora untuk Linux, CentOS, dan Scientific Linux melalui Paket Ekstra untuk Enterprise Linux (EPEL) serta untuk sistem operasi lain.

Bahasa Asal

SaltStack - Python
Puppet - Ruby
Chef - Ruby dan CLI-nya menggunakan DSL berbasis ruby
Ansible - Python

Bahasa yang Didukung

SaltStack - Bahasa apapun
Puppet - Ruby
Chef - Ruby dan CLI-nya menggunakan DSL berbasis ruby
Ansible - Bahasa apapun

UI web

SaltStack - UI Web menawarkan tampilan pekerjaan yang sedang berjalan, status minion dan log peristiwa.
Puppet - UI Web menangani pelaporan, inventaris, dan manajemen node waktu nyata.
Chef - UI Web memungkinkan Anda mencari dan menginventarisir node, melihat aktivitas node, dan menetapkan Cookbook, peran, dan node.
Ansible - UI Web memungkinkan Anda mengonfigurasi pengguna, tim, dan inventaris, serta menerapkan PlayBook ke inventaris.

Alat Manajemen

SaltStack - SaltStack Enterprise diposisikan sebagai alat utama untuk mengelola orkestrasi cloud dan operasi TI, serta DevOps.
Puppet- Puppet hadir dalam dua varian, Puppet Enterprise dan Open Source Puppet. Selain menyediakan fungsionalitas dari Open Source Puppet, Puppet Enterprise juga menyediakan GUI, API dan alat baris perintah untuk manajemen node.
Chef - CFEngine adalah alat manajemen konfigurasi.
Ansible - Ansible 1.3 adalah alat utama untuk manajemen.

Performa

SaltStack- Garam dirancang untuk kinerja tinggi dan skalabilitas. Sistem komunikasi Salt membuat pipa data yang persisten antara master Salt dan minion menggunakan ZeroMQ.
Puppet - Aman serta berkinerja tinggi dan tidak diperlukan agen.
Chef- Perjuangan paling nyata untuk Chef Server adalah pencarian; Pencarian lambat dan tidak diminta secara bersamaan dari klien.
Ansible - Aman, berkinerja tinggi dan tidak diperlukan agen.

Harga dan Nilai

SaltStack- Versi open source gratis. SaltStack Enterprise berharga $ 150 per mesin per tahun.
Puppet- Versi open source gratis. Puppet Enterprise berharga $ 100 per mesin per tahun.
Chef- Versi open source gratis; Enterprise Chef gratis untuk 5 mesin, $ 120 per bulan untuk 20 mesin, $ 300 per bulan untuk 50 mesin.
Ansible- Versi open source gratis; Bisa gratis untuk 10 mesin, lalu $ 100 atau $ 250 per mesin per tahun tergantung pada dukungan yang Anda butuhkan.

Pemakaian

SaltStack- SaltStack digunakan oleh Cisco dan Rackspace. Itu dapat berintegrasi dengan platform berbasis cloud apa pun.
Puppet - Wayang digunakan oleh Zynga, Twitter, Bursa Efek New York, PayPal, Disney, Google, dan sebagainya.
Chef - Chef dapat berintegrasi dengan platform berbasis cloud seperti Internap, Amazon EC2, Google Cloud Platform, OpenStack, Microsoft Azure, dan Rackspace.
Ansible - Ansible dapat diterapkan ke lingkungan virtualisasi, lingkungan cloud termasuk Amazon Web Services, Cloud Stack, DigitalOcean, dan Google Cloud Platform, dan sebagainya.

Sebelum pindah ke instalasi, Anda harus memiliki persyaratan berikut -

Server Linux (server Ubuntu terbaru).
sudo atau root access ke server ini.

Instal semua pembaruan menggunakan perintah berikut -

sudo apt-get update

Pasang SaltMaster

Instal SaltMaster dari repositori dengan perintah apt-get berikut.

sudo apt-get install salt-master

Pasang Salt Minion

Instal minion Salt dari repositori dengan perintah apt-get berikut.

sudo apt-get install salt-minion

Pasang sindik Salt

Instal sindik Salt dari repositori dengan perintah apt-get berikut.

sudo apt-get install salt-syndic

Konfigurasi Utama

Konfigurasi garam sangat sederhana. Konfigurasi default untuk master akan berfungsi untuk sebagian besar instalasi. File konfigurasi dipasang di direktori '/ etc / salt' dan diberi nama sesuai dengan komponennya masing-masing, seperti - / etc / salt / master dan / etc / salt / minion.

#interface: 0.0.0.0
interface: <local ip address>

Setelah memperbarui file konfigurasi, restart master Salt menggunakan perintah berikut.

sudo service salt-master restart

Konfigurasi Minion

Mengonfigurasi Salt Minion sangat sederhana. Secara default, Salt Minion akan mencoba untuk terhubung ke nama DNS "salt"; jika Minion dapat menyelesaikan nama itu dengan benar, tidak diperlukan konfigurasi. Definisikan ulang direktif "master" dalam file konfigurasi minion, yang biasanya/etc/salt/minion, seperti yang ditunjukkan pada kode di bawah ini -

#master: salt
master: <local ip address>

Setelah memperbarui file konfigurasi, restart minion Salt menggunakan perintah di bawah ini.

sudo service salt-minion restart

Manajemen Kunci

Penggunaan garam AES Encryptionuntuk semua komunikasi antara Master dan Minion. Komunikasi antara Master dan Minion diautentikasi melalui kunci tepercaya yang diterima.

salt-key -L

Ini akan menghasilkan yang berikut ini output -

Accepted Keys:
Denied Keys:
Unaccepted Keys:
<local system name>
Rejected Keys:

Terima semua kunci dengan mengeluarkan perintah di bawah ini.

sudo salt-key -A

Ini akan menghasilkan yang berikut ini output -

The following keys are going to be accepted:
Unaccepted Keys:
<local system name>
Proceed? [n/Y] y
Key for minion bala-Inspiron-N4010 accepted.

Sekarang, keluarkan lagi salt key listing perintah,

salt-key -L

Ini akan menghasilkan yang berikut ini output -

Accepted Keys:
<local system name>
Denied Keys:
Unaccepted Keys:
Rejected Keys:

Mengirim Perintah

Komunikasi antara Master dan Minion harus diverifikasi dengan menjalankan perintah test.ping.

sudo salt '*' test.ping

Ini akan menghasilkan yang berikut ini output -

<local system name>
   True

Di sini, '*' mengacu pada semua antek. Karena, kami hanya memiliki satu minion - test.ping, itu mengeksekusiping perintah dan mengembalikan apakah ping berhasil atau tidak.

Di bab ini, kita akan membuat lingkungan SaltStack sederhana, satu master garam, dan dua minion garam. Lingkungan ini akan membantu kita mempelajari konsep garam di bab-bab selanjutnya.

Mari kita ikuti langkah-langkah berikut untuk membuat lingkungan SaltStack.

Instal Lingkungan VirtualBox

VirtualBox adalah aplikasi virtualisasi lintas platform. VirtualBox memungkinkan Anda menjalankan lebih dari satu sistem operasi dalam satu waktu. VirtualBox berjalan di Windows, Linux, Macintosh dan Solaris. Ini menjadi tuan rumah dan mendukung sejumlah besarGuest Operating Systems.

Anda dapat mengunduh dan menginstal VirtualBox dengan mengunjungi tautan berikut - https://www.virtualbox.org/wiki/Downloads

Kami akan membuat tiga mesin virtual dan menjalankannya menggunakan VirtualBox.

Pasang Vagrant

Vagrant menyediakan lingkungan kerja yang mudah dikonfigurasi, dapat direproduksi, dan portabel.

Anda dapat mengunduh dan menginstal Vagrant dengan mengunjungi tautan berikut - https://www.vagrantup.com

Setelah instalasi Vagrant berhasil, Anda perlu mengkonfigurasinya. Buat satu file bernamaVagrantfile dalam folder dan jelaskan jenis mesin dan propertinya.

Run Vagrant - Untuk menjalankan Vagrant, jalankan perintah berikut -

vagrant up

Setelah Anda menjalankan vagrant up, Vagrant membuat dan memulai mesin tersebut, yang ditentukan di file Vagrantfilemenggunakan VirtualBox di latar belakang. Mesin ini akan bekerja sampai Anda menutupnya.

Stop Vagrant - Untuk menghentikan semua mesin yang berjalan di VirtualBox, ketik perintah berikut -

vagrant halt

Unduh Lingkungan Demo

SaltStack menyediakan lingkungan demo sederhana sebagai penyiapan Vagrant dan dihosting di github. Mari kita unduh pengaturan menggunakan perintah berikut -

cd /cd/to/path

git clone https://github.com/UtahDave/salt-vagrant-demo

Mulai Lingkungan

Sekarang, mulai lingkungan demo menggunakan perintah berikut -

cd /cd/to/path/salt-vagrant-demo
vagrant up

Setelah perintah ini, Anda akan melihat respons berikut -

result

Sekarang, tiga server sedang berjalan, satu dengan master garam dikonfigurasi dan dua dengan minion garam dikonfigurasi.

Jalankan master Salt

Masuk ke master Salt menggunakan perintah berikut -

vagrant ssh master

Sekarang, pindah ke pengguna root menggunakan perintah di bawah ini -

sudo su

Sekarang kami telah berhasil terhubung ke master Salt.

Sekarang mari kita membahas beberapa perintah dasar di SaltStack.

Buat daftar semua Kunci

Perintah berikut adalah untuk memverifikasi koneksi antek Salt dan melihat apakah koneksi diterima, ditolak atau tertunda.

salt-key —list-all

Ini akan menghasilkan yang berikut ini output -

Accepted Keys:
minion1
minion2
Denied Keys:

Unaccepted Keys:
Rejected Keys:

Verifikasi Salt Minions

Sekarang, kami telah menerima semua kunci, Anda dapat mengirim perintah dari master Salt untuk memeriksa apakah minion Salt mendengarkan atau tidak,

salt '*' test.ping

Ini akan menghasilkan yang berikut ini output -

minion1:
   True
minion2:
   True

Dari hasil di atas, buat daftar minion 1 dan minion 2, yang berarti minion mendengarkan dengan baik, jika tidak, minion sekarang mungkin merespons dengan benar.

Sistem Kontrol Akses menyediakan opsi bagi pengguna untuk grup untuk menjalankan tugas dengan izin. Sistem kontrol akses Salt digunakan untuk mengkonfigurasi akses ke antarmuka kontrol non-administratif. Anda dapat menerapkan proses ini ke semua sistem. Kontrol ini membantu pengguna non-administratif untuk menjalankan perintah Salt.

Antarmuka garam terdiri dari tiga jenis berikut -

Sistem ACL penerbit
Sistem Otorisasi Eksternal
Sistem rekan

Mari kita pahami melalui masing-masing antarmuka ini secara detail.

Sistem ACL Penerbit

Sistem ACL Publisher memungkinkan akses ke pengguna selain root untuk menjalankan perintah Salt pada minion dari master. Sistem ACL penerbit dikonfigurasikan dalam file konfigurasi master melaluipublisher_aclopsi konfigurasi. Ini didefinisikan sebagai berikut -

publisher_acl:
   user1:
      - .*

   user2:
      - web*:
         - test.*
         - pkg.*

Sini,

user1 diperbolehkan untuk melakukan apapun.
user2 diizinkan untuk digunakan test dan pkg, tetapi hanya di antek “web *”.

Sistem Otorisasi Eksternal

Itu external auth system digunakan untuk menyediakan akses untuk menjalankan perintah salt pada minion tertentu melalui sistem otorisasi eksternal seperti PAM, LDAP, dll. File konfigurasi ini didefinisikan dalam file master seperti yang dijelaskan di bawah ini.

external_auth:
   pam:
      user1:
         - 'web*':
            - test.*
            - network.*
      user2:
         - .*

Sini,

user1 diizinkan untuk menjalankan fungsi di test dan network modules pada antek yang cocok dengan web* target.
user2 diizinkan untuk menjalankan semua fungsi.

Aktifkan Sistem Autentikasi Eksternal dalam Perintah

Server garam menyediakan opsi '–a' untuk mengaktifkan otentikasi eksternal.

salt -a pam web\* test.ping

Di sini -a pamopsi digunakan untuk mengaktifkan otentikasi eksternal PAM. Salt Server akan meminta detail otentikasi setiap kali kami menjalankan perintah. Untuk membatasi Salt Server agar tidak menanyakan detail otentikasi untuk pertama kalinya saja, kita dapat menggunakan opsi T. Ini-T option cache detail otentikasi selama 12 jam berikutnya (pengaturan default) dan menggunakannya untuk mengotentikasi pengguna.

salt -T -a pam web\* test.ping

Sistem Peer

Salt minion dapat memberikan perintah menggunakan antarmuka peer. Antarmuka peer dikonfigurasi melalui file konfigurasi master untuk memungkinkan minion mengirim perintah dari master menggunakan filepeer konfigurasi atau untuk mengizinkan minion mengeksekusi runner dari master menggunakan peer_run konfigurasi.

Mari kita pahami kedua konfigurasi ini secara mendetail.

Konfigurasi peer

Konfigurasi sederhana untuk didefinisikan dalam file master adalah sebagai berikut -

peer:
   .*:
      - .*

Di sini, Ini memungkinkan komunikasi untuk semua antek, tetapi hanya disarankan untuk lingkungan yang sangat aman.

Untuk menetapkan minion ke ID tertentu, konfigurasi perlu ditentukan seperti yang ditunjukkan di bawah ini: peer -

.*domain.com:
   - test.*

Konfigurasi peer_run

Konfigurasi ini untuk memungkinkan minion mengeksekusi runner dari master menggunakan opsi peer_run pada file master. Contoh berikut adalah untuk mengizinkan akses ke semua antek dan semua pelari.

peer_run:
   .*:
      - .*

Untuk menetapkan minion ke ID tertentu, konfigurasi perlu ditentukan seperti yang diberikan di bawah ini -

peer_run:
   .*domain.com:
      - test.*

Bagaimana Menjalankan Perintah

Untuk mengeksekusi test.ping di semua minion, gunakan salt-call perintah bersama dengan publish.publish modul.

salt-call publish.publish \* test.ping

Untuk mengeksekusi runner, gunakan perintah salt-call bersama dengan publish.runner modul.

salt-call publish.runner manage.up

Salt memiliki kemampuan komunikasi berkecepatan tinggi dengan sejumlah besar sistem. Pendekatan ini membantu Salt membuat sistem multitasking yang hebat. Salt dapat menjalankan pekerjaan di lebih dari satu sistem, jadi Salt menggunakan teknik manajemen pekerjaan untuk mengelola setiap pekerjaan yang berjalan di semua sistem. Bab ini menjelaskan tentang manajemen pekerjaan secara rinci.

Apa itu ID Pekerjaan?

Salt memiliki direktori cache, cachedir. Di dalamnya, direktori yang dipelihara oleh minion disebut sebagaiprocdirektori. Itu terletak di direktori berikut / var / cache / salt / proc.

Direktori proc digunakan untuk memelihara semua file. Ketika file-file ini dijalankan, mereka menetapkan dengan ID pekerjaan yang unik. ID pekerjaan ini membantu mengidentifikasi pekerjaan yang sedang berjalan di minion dan memungkinkan pekerjaan untuk dicari.

Modul SALTUTIL

Salt memperkenalkan modul baru yang disebut sebagai proses manajemen pekerjaan Saltutil. Modul ini berisi berbagai fungsi untuk mengelola pekerjaan. Fungsi ini digunakan untuk mengelola pekerjaan di level minion. Fungsi-fungsi tersebut dijelaskan secara singkat sebagai berikut -

running - Mengembalikan semua data pekerjaan yang sedang berjalan yang ditemukan di direktori proc.
find_job - Menampilkan data spesifik tentang pekerjaan tertentu berdasarkan id pekerjaan.
signal_job - Memungkinkan id pekerjaan yang diberikan (jid) untuk mengirim sinyal.
term_job - Mengirim sinyal penghentian untuk pekerjaan tertentu.
kill_job - Mengirim sinyal kill untuk pekerjaan yang ditentukan.

Pekerjaan Runner

Pelari pekerjaan berisi fungsi untuk membuat tampilan data lebih mudah dan lebih bersih. Ini memiliki fungsi yang berbeda. Mari kita bahas masing-masing fungsi ini secara rinci.

Fungsi AKTIF

Fungsi Aktif digunakan untuk mengidentifikasi pekerjaan mana yang masih berjalan dan memeriksa sistem apa yang telah menyelesaikan pekerjaan dan sistem apa yang masih menunggu. Ini dijalankan menggunakan perintah berikut,

salt-run jobs.active

Fungsi LOOKUP_JID

Pelari lookup_jid akan menampilkan data untuk pekerjaan pencarian saat ini. Pekerjaan ini dikonfigurasi melaluikeep_jobsopsi dalam konfigurasi master. Ini dijalankan menggunakan perintah berikut.

salt-run jobs.lookup_jid <job id number>

Fungsi LIST_JOBS

Fungsi List_jobs digunakan untuk membuat daftar data pekerjaan untuk pekerjaan. Itu diekspresikan dengan perintah berikut -

salt-run jobs.list_jobs

Penjadwalan Pekerjaan

Sistem jadwal mengeksekusi eksekusi fungsi eksekusi apa pun pada minion atau pelari mana pun di master.

Itu dilakukan dengan metode berikut -

Schedule - Opsi jadwal di master atau antek config file.
Minion pillar data - Ini menyegarkan data pilar minion menggunakan perintah saltutil.refresh_pillar.
Status jadwal atau modul jadwal.

Status garam dieksekusi di minion. Anda dapat meneruskan argumen posisi dan memberikanYAML dict dari argumen bernama di config file seperti gambar dibawah.

schedule:
   job1:
      function: saltstate.sls
      seconds: 3600
      args:
         - httpd
      kwargs:
         test: True

Sini, job1 akan menjalankan fungsinya saltstate.sls dengan argumen yang ditentukan, httpduntuk setiap jam. Itutest: True adalah argumen tambahan untuk httpd perintah yang didefinisikan di saltstate.sls.

Server file Salt adalah server ZeroMQ tanpa negara. Itu dibangun ke dalam master Salt. Server file Salt digunakan untuk mendistribusikan file dari master ke antek. Ini berisi modul yang berbeda. Mari kita pahami server file garam, konfigurasinya, modul yang terkait dengan server file garam, cara mengakses server file garam di python, dll., Di bab ini.

File Server Backend

Backend server file memungkinkan server file Salt bertindak sebagai antarmuka transparan ke server file lain seperti sistem file lokal, sistem kontrol versi Git, dll.

Backend server file Git dapat diaktifkan dengan menggunakan konfigurasi berikut di file master.

fileserver_backend:
   - git

Untuk mengaktifkan beberapa sistem file backend, kita dapat menggunakan konfigurasi berikut.

fileserver_backend:
   - roots
   - git

Kami juga dapat menentukan opsi tambahan untuk server backend yang berbeda menggunakan bagian tertentu dari server backend yang sesuai.

Sistem File Lokal

Untuk menggunakan sistem ini, kita harus menggunakan kode berikut.

file_roots:
   base:
      - /srv/salt/prod

Sistem File Git

Untuk menggunakan sistem ini, kita harus menggunakan kode berikut.

gitfs_remotes:
   - https://github.com/sample/sample1.git

Meminta File

Salt memiliki opsi untuk meminta file untuk lingkungan tertentu.

salt://path/to/file?saltenv = base

Di sini, lingkungan ditentukan menggunakan opsi akar.

Konfigurasi Server File

File Salt dapat dialokasikan dalam banyak direktori root dan diakses dengan menentukan jalur file dan lingkungan yang akan dicari. Lingkungan individu dapat menjangkau beberapa akar direktori.

Lingkungan Hidup

Lingkungan default adalah basis. Lingkungan ini ditentukan dan digunakan untuk mengunduh file ketika tidak ada lingkungan lain yang ditentukan.

file_roots:
   base:
      - /srv/salt/base

Anda juga dapat menggunakan beberapa lingkungan seperti yang ditunjukkan pada kode di bawah ini.

file_roots:
   base:
      - /srv/salt/base
   dev:
      - /srv/salt/dev
      - /srv/salt/base

Modul CP

Modul CP adalah modul utama untuk memanipulasi Salt file server. Itusalt-cp perintah juga dapat digunakan untuk mendistribusikan file yang disajikan oleh server file Salt.

GET_FILE

Itu cp.get_filefungsi minion dapat digunakan untuk mengunduh file dari master. Ini didefinisikan seperti yang ditunjukkan pada blok kode berikut.

salt '*' cp.get_file salt://vimrc /etc/vimrc

Perintah di atas menginstruksikan semua minion Salt untuk mengunduh vimrc file dan salin ke /etc/vimrc.

Aktifkan Template

Anda dapat mengaktifkan opsi template di get_file sebagai berikut -

salt '*' cp.get_file "salt://vimrc" /etc/vimrc template = jinja

Terapkan Kompresi

Untuk menggunakan kompresi, gunakan gzipargumen bernama. Nilai yang valid adalah bilangan bulat dari 1 hingga 9, di mana 1 adalah kompresi minimum dan 9 adalah nilai maksimum.

Perintah tersebut didefinisikan sebagai berikut -

salt '*' cp.get_file salt://vimrc /etc/vimrc gzip = 5

GET_DIR

Itu cp.get_dirfungsi dapat digunakan pada minion untuk mengunduh seluruh direktori dari master. Ini didefinisikan dalam blok kode berikut.

salt '*' cp.get_dir salt://etc/mysql /etc

Itu cp.get_dirmendukung rendering template dan argumen kompresi gzip. Jika mau, Anda juga bisa menugaskan.

Modul FILECLIENT

Salt menyediakan modul python yang membantu mengakses server file garam. Itusalt/fileclient.py modul digunakan untuk mengatur komunikasi dari minion ke master.

Kode contoh untuk mendapatkan file adalah sebagai berikut -

import salt.minion
import salt.fileclient

def get_file(path, dest, saltenv = ‘base'):
   client = salt.fileclient.get_file_client(__opts__)
   return client.get_file(path, dest, true, saltenv)

Sini,

opts tersedia saat modul dijalankan di lingkungan salt. Jika tidak, kita harus menyediakan jalur konfigurasi -/etc/salt/minion.
path merujuk ke jalur file sumber di server file garam.
dest mengacu pada jalur tujuan file.
saltenv mengacu pada lingkungan

Di bab selanjutnya, kita akan memahami cara menggunakan Git sebagai file server.

Gitadalah sistem kontrol versi terdistribusi sumber terbuka. Ini dapat digunakan untuk melacak perubahan dalam file apa pun. Salt mengirim file dari repositori Git menggunakan server file Git. Anda dapat mengkonfigurasi Git ke filefileserver_backend list dan jika Anda perlu mengkonfigurasi satu atau lebih repositori, Anda dapat melakukannya dengan menggunakan gitfs_remotes pilihan.

Bab ini menjelaskan tentang cara menginstal dan mengkonfigurasi server file Git. Sebelum melanjutkan ke penginstalan, Anda harus memiliki prasyarat berikut.

Prasyarat Salt Server untuk Menggunakan Git

Persyaratan minimal bagi server garam untuk menggunakan Git sebagai server berkas adalah sebagai berikut -

pygit2
Dulwich

Pygit2 dan Dulwich dikonfigurasikan menggunakan gitfs_providerparameter dalam file konfigurasi master. Jikagitfs_provider tidak dikonfigurasi dalam file master maka Salt akan memilih pygit2, jika versi yang sesuai tersedia, diikuti oleh GitPython dan Dulwich.

Pasang pygit2

Perintah berikut digunakan untuk menginstal pygit2 di sistem berbasis Fedora dan Ubuntu -

Fedora-based system

yum install python-pygit2

Ubuntu-based system

apt-get install python-pygit2

Di sini, versi pygit2 minimum yang didukung adalah 0.20.3.

Instal GitPYTHON

GitPython dapat dengan mudah diinstal pada master menggunakan file yum / apt command seperti gambar dibawah.

Fedora-based system

yum install GitPython

Ubuntu-based system

apt-get install python-git

Instal DULWICH

Dulwich dapat dengan mudah diinstal pada master menggunakan perintah yum.

Fedora-based system

yum install python-dulwich

Ubuntu-based system

apt-get install python-dulwich

Sekarang, kami telah menginstal semua dependensi untuk server file Git. Sekarang mari kita konfigurasikan server file Git ini menggunakanfileserver_backend bagian di master config mengajukan.

Konfigurasi Backend

Untuk menggunakan server file Git, Anda perlu menambahkan Git di daftar fileserver_backend di file konfigurasi master. Ini dijelaskan sebagai berikut -

fileserver_backend:
   - git

Mari kita pahami lebih lanjut cara mengkonfigurasi server file Git dalam konfigurasi jarak jauh.

Konfigurasi gitfs_remotes

Anda dapat menentukan salah satu atau semua URL seperti git: //, https: //, file: //, atau ssh: // untuk konfigurasi gitfs_remotes di file master. Ini digunakan untuk mencari file yang diminta.

Spesifikasi URL https sederhana dijelaskan di bawah.

gitfs_remotes:
   - https://github.com

Itu ssh konfigurasi dapat dilakukan seperti gambar di bawah ini.

gitfs_remotes:
   - [email protected]:user1/sample.git
   - ssh://[email protected]/path/to/sample.git

Sekarang, kami telah mengonfigurasi server file Git menggunakan dua opsi fileserver_backend dan gitfs_remotes.

Mulai ulang Master

Setelah melakukan semua perubahan pada file master, sekarang restart master untuk memuat semua konfigurasi di server file Git.

Konfigurasi Beberapa Jarak Jauh

Perintah berikut digunakan untuk beberapa konfigurasi di gitfs_remotes di file master.

gitfs_remotes:
   - git://github.com/sample/sample1.git
   - https://github.com/sample/sample2.git
   - file:///root/user/sample

Di sini, repositori sample1.git, sample2.git, dan sample.doc mungkin memiliki file-file berikut.

sample1.git:
   top.sls
   
sample2.git
   edit/vimrc
   
sample.doc
   edit/vimrc

Itu MinionFSadalah server file khusus yang disediakan oleh Salt untuk minion untuk bertukar file di antara mereka. File yang disajikan oleh MinionFS adalah file yang sengaja dibagikan oleh minion. Untuk membagikan file, Minion harus mengikuti langkah-langkah yang diberikan di bawah ini.

Minion sumber harus mendorong file ke master garam menggunakan cp.push fungsi.
Setelah file didorong oleh minion sumber, file yang diterapkan dapat diakses oleh antek lain menggunakan server file MinionFS.

Aktifkan Mendorong

Secara default, mendorong file oleh minion ke master dinonaktifkan. Untuk menerima file dari minion, master harus memiliki opsi "file_recv" di file konfigurasi dan nilainya harus disetel keTrue. Secara default, nilai jika "file_recv" adalahfalse.

file_recv: True

Setelah opsi diaktifkan, mulai ulang layanan master.

Mendorong File

Minion dapat mengirimkan file ke master. Ini dilakukan olehcp.pushfungsi. Fungsi cp.push ini menyediakan mekanisme yang mudah untuk mendorong file dengan minion menggunakan id minion.

salt 'minion-id' cp.push /path/to/the/file

Di sini, minion-id digunakan untuk mengidentifikasi minion mana yang mendorong file. Perintah ini akan menyimpan file dalam subdirektori bernamaminions di bawah master's cachedir. Biasanya, jalurnya adalah - / var / cache / salt / master / minions.

Untuk antek, m1 dan file - /var/log/mylog.txt, file tersebut akan disimpan di - /var/cache/salt/master/minions/m1/var/log/mylog.txt.

Aktifkan MinionFS

Untuk mengaktifkan MinionFS, cukup tambahkan minion dalam pengaturan backend server file seperti yang ditunjukkan pada blok kode berikut.

fileserver_backend:
   - roots
   - minion

Setelah MinionFS diaktifkan, file yang didorong oleh minion tersedia sebagai -

salt://<minion-id>/path/to/pushed/file

Untuk antek, m1 dan file yang didorong - /var/log/mylog.txt, file yang didorong akan disajikan dari salt: //m1/var/log/mylog.txt.

MinionFS ini dapat dipasang di direktori khusus menggunakan konfigurasi berikut. Ini akan memisahkan file minionFS dari file lain dan akan membantu dalam mengatur file minion.

minionfs_mountpoint: salt://minionfs

Untuk konfigurasi di atas, file akan tersedia di bawah minionfs direktori sebagai - salt: //minionfs/m1/var/log/mylog.txt

Opsi Lanjutan MinionFS

MinionFS juga menyediakan opsi untuk mengaktifkan / menonaktifkan ketersediaan file yang didorong dari minion tertentu. Opsinya adalahminionfs_whitelist, untuk mengaktifkan antek dan minionfs_blacklist, untuk menonaktifkan minion.

minionfs_whitelist:
   - webserver
   - develop*
   - ‘mail\d+.mysite.com'

minionfs_blacklist:
   - testing

Dalam konfigurasi di atas, semua minion kecuali testing diizinkan untuk membagikan file menggunakan minionFS.

Webserver1
Minion yang idnya cocok dengan ekspresi reguler akan berkembang *
Minion yang ID-nya cocok dengan ekspresi reguler mail\d+.mysite.com.
Testing

Di bab selanjutnya, kita akan mempelajari cara menggunakan Cron dengan Salt.

Garam dapat digunakan bersama dengan Cronaplikasi. Menggunakan kedua aplikasi secara bersamaan memberikan peluang besar untuk mengotomatiskan Salt. Sementara Salt menyediakan opsi untuk menjalankan perintah dari jarak jauh, Cron memungkinkannya untuk berjalan dengan cara yang telah dijadwalkan sebelumnya atau otomatis. Mari kita pelajari cara menggunakan Cron dan Salt bersama-sama di bab ini.

Apa itu Cron?

Cron adalah aplikasi yang sangat berguna di Lingkungan Linux. Ini memungkinkan untuk mengatur sebuah perintah atau skrip untuk dijalankan pada tanggal dan waktu tertentu. Ini juga memungkinkan untuk menjalankan aplikasi dalam interval reguler, katakanlah harian, mingguan, atau setiap hari pertama setiap bulan.

Cron dimulai saat sistem dimulai dan periksa /etc/crontabfile untuk detail konfigurasi. / Etc / crontab memiliki setiap aplikasi dan jadwalnya dalam baris terpisah seperti yang ditunjukkan di bawah ini.

15 * * * * root echo "This command runs at 15 minutes past every hour"
15 10 * * * root echo "This command is run daily at 10:15 am"

Setiap baris memiliki tujuh titik masuk berikut, yang dipisahkan oleh spasi dan adalah sebagai berikut -

minute - menit dalam satu jam dan berada di antara '0' dan '59'.
hour - jam dan ditentukan dalam format 24 jam.
day_of_month- Hari Bulan dan antara 1 dan 31. Sebagai contoh, 10 ^th setiap bulan adalah 10.
month - Bulan ditentukan dan ditentukan secara numerik (0-12), atau sebagai nama bulan (misalnya Mei).
day_of_week - Hari dalam seminggu ditentukan secara numerik (0-7) atau sebagai nama hari (mis. Matahari).
user - Akun pengguna tempat perintah dijalankan.
cmd - Perintah aktual dan argumennya.

Di sini, * menggantikan, jika tidak ada yang ditetapkan.

Salt Caller (panggilan garam)

Salt menyediakan CLI (Command Line Interface), salt-calluntuk menjalankan modul di sistem minion lokal itu sendiri, bukan dari server master menggunakan perintah salt. Salt call CLI mendukung semua opsi yang didukung oleh perintah salt, tetapi berjalan secara lokal.

Salt Caller awalnya dirancang untuk mendukung debugging, tetapi sekarang, dapat digunakan sebagai aplikasi mandiri.

salt-call test.ping

Menggunakan salt-call di cron

CLI panggilan garam berguna untuk menjadwalkan operasi garam menggunakan Cron. Misal, untuk mengecek status minion setiap hari tengah malam, kita bisa menggunakan salt-call bersama dengan opsi - state.apply seperti gambar di bawah ini.

/etc/crontab

PATH = /bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:/opt/bin
0 0 * * * salt-call state.apply

Sini,

Itu state.apply function akan memeriksa file konfigurasi garam untuk minion dan memeriksa apakah semua tindakan yang ditentukan untuk minion sudah dikonfigurasi dengan benar.
Menyetel jalur adalah praktik yang baik karena terkadang perintah salt mungkin tidak tersedia di jalur sistem.

Di bab berikutnya, kita akan mempelajari Eksekusi Jarak Jauh, yang merupakan konsep inti Salt.

Salah satu konsep inti Salt adalah eksekusi jarak jauh. Salt dapat menjalankan perintah di ribuan sistem dalam hitungan detik. Salt menggunakan perintahnya sendiri untuk melakukan fungsi ini. Mari kita sekarang memahami berbagai perintah Salt untuk eksekusi jarak jauh di bab ini.

Perintah Garam

Perintah Salt memungkinkan master Salt untuk berkomunikasi dengan satu atau lebih Salt minions. Sintaks dasarnya adalah sebagai berikut,

salt '<target>' <module.function> [arguments]

Sintaks perintah di atas terdiri dari tiga komponen utama berikut.

target - Ini menentukan sistem mana yang diterapkan oleh perintah.
module.function- Itu adalah perintah. Perintah terdiri dari modul dan fungsi.
arguments - Data tambahan yang diperlukan untuk memanggil fungsi tersebut.

Mari kita pahami masing-masing komponen secara detail.

Apa itu Komponen Target?

Target adalah komponen, yang memungkinkan Anda untuk memfilter minion (sistem terkelola) untuk menjalankan fungsi tersebut. Perintah sederhana yang menggunakan komponen target didefinisikan di bawah ini.

salt '*' test.ping

Ini akan menghasilkan yang berikut ini output -

minion2:
   True
minion1:
   True

Di sini, targetnya ‘*’mewakili semua sistem yang dikelola. 'test'di sini adalah modul dan pingadalah sebuah fungsi. Ini digunakan untuk menguji layanan ping di sistem jarak jauh. Kita akan belajar tentang berbagai modul dan fungsinya di bab-bab selanjutnya.

Target menggunakan ID (minion)

Anda dapat mengirim perintah ke antek tertentu menggunakan iddi target. Daripada menggunakan'*', Anda bisa menggantinya menggunakan minion id. Ini didefinisikan di bawah.

salt 'minion1’ test.ping

Ini akan menghasilkan yang berikut ini output -

minion1:
   True

Target menggunakan Ekspresi Reguler

Target dapat difilter dengan ekspresi reguler tertentu. Ini didefinisikan di bawah.

salt -E 'minion[0-9]' test.ping

Ini akan menghasilkan yang berikut ini output -

minion2:
   True
minion1:
   True

Target menggunakan Daftar

Target dapat ditentukan secara eksplisit dalam daftar. Ini didefinisikan dalam blok kode berikut.

salt -L 'minion1,minion2' test.ping

Ini akan menghasilkan yang berikut ini output -

minion2:
   True
minion1:
   True

Target berdasarkan Kondisi

Target dapat digabungkan dalam satu perintah seperti yang ditunjukkan pada blok kode di bawah ini.

salt -C 'G@os:Ubuntu and minion* or [email protected].*' test.ping

Ini akan menghasilkan yang berikut ini output -

minion1:
   True
minion2:
   True

Modul dan Fungsi (modul.fungsi)

Salt dapat menjalankan perintah shell; perbarui paket dan distribusikan file, dll., di semua sistem yang dikelola secara bersamaan. Salt melakukan operasi ini menggunakan modul. Salt memiliki modul khusus untuk semua fungsi yang tersedia. Mari kita pahami modul Salt yang berbeda menggunakan beberapa contoh sederhana di bab ini.

Perintah Shell

Salt menjalankan perintah shell dari jarak jauh di beberapa sistem menggunakan cmd.runperintah. Itucmd adalah modul utama dan run adalah salah satu fungsi yang tersedia di cmdmodul. Iturun fungsi memungkinkan perintah shell untuk dijalankan di sistem jarak jauh seperti yang ditunjukkan pada blok kode di bawah ini.

salt '*' cmd.run 'ls -l /etc'

Ini akan menghasilkan yang berikut ini output -

minion2:
   total 868
   drwxr-xr-x 7 root root    4096 Jan 26 22:10 X11
   drwxr-xr-x 3 root root    4096 Jan 26 21:02 acpi
   -rw-r--r-- 1 root root    2981 Jan 26 20:48 adduser.conf
   -rw-r--r-- 1 root root      10 Jan 26 21:04 adjtime
   drwxr-xr-x 2 root root    4096 Jan 26 22:10 alternatives
   drwxr-xr-x 3 root root    4096 Jan 26 20:53 apm
   drwxr-xr-x 3 root root    4096 Jan 26 21:02 apparmor
   drwxr-xr-x 9 root root    4096 Jan 26 21:02 apparmor.d
   drwxr-xr-x 3 root root    4096 Jan 26 21:02 apport
   drwxr-xr-x 6 root root    4096 Jan 29 07:14 apt
   drwxr-xr-x 2 root root    4096 Jan 26 22:10 at-spi2
……………
……………
minion1:
   total 868
   drwxr-xr-x 7 root root    4096 Jan 26 22:10 X11
   drwxr-xr-x 3 root root    4096 Jan 26 21:02 acpi
   -rw-r--r-- 1 root root    2981 Jan 26 20:48 adduser.conf
   -rw-r--r-- 1 root root      10 Jan 26 21:04 adjtime
   drwxr-xr-x 2 root root    4096 Jan 26 22:10 alternatives
   drwxr-xr-x 3 root root    4096 Jan 26 20:53 apm

   drwxr-xr-x 3 root root    4096 Jan 26 21:02 apparmor
   drwxr-xr-x 9 root root    4096 Jan 26 21:02 apparmor.d
   drwxr-xr-x 3 root root    4096 Jan 26 21:02 apport
   drwxr-xr-x 6 root root    4096 Jan 29 07:09 apt
   drwxr-xr-x 2 root root    4096 Jan 26 22:10 at-spi2
   -rw-r----- 1 root daemon   144 Oct 21  2013 at.deny
   -rw-r--r-- 1 root root    2177 Apr  9  2014 bash.bashrc
   -rw-r--r-- 1 root root      45 Mar 22  2014 bash_completion
……………
……………

Tampilkan Penggunaan Disk

Salt menyediakan modul khusus, diskuntuk mendapatkan detail lengkap disk dari sistem yang dikelola. Itudiskmodule mempunyai sebuah usage berfungsi untuk menanyakan detailnya.

salt '*' disk.usage

Ini akan menghasilkan yang berikut ini output -

minion1:
   ----------
   /:
      ----------
      1K-blocks:
         41251136
      available:
         37852804
      capacity:
         5%
      filesystem:
         /dev/sda1
      used:
         1662420
   /dev:
      ----------
      1K-blocks:
         503908
      available:
         503896
      capacity:
         1%
      filesystem:
         udev
      used:
         12
   /run:
      ----------
      1K-blocks:
         101780
      available:
         101412
      capacity:
         1%
      filesystem:
         tmpfs
      used:
         368
   /run/lock:
      ----------
      1K-blocks:
         5120
      available:
         5120
      capacity:
         0%
      filesystem:
         none
      used:
         0
   /run/shm:
      ----------
      1K-blocks:
         508884
      available:
         508872
      capacity:
         1%
      filesystem:
         none
      used:
         12
   /run/user:
      ----------
      1K-blocks:
         102400
      available:
         102400
      capacity:
         0%
      filesystem:
         none
      used:
         0
   /sys/fs/cgroup:
      ----------
      1K-blocks:
         4
      available:
         4
      capacity:
         0%
      filesystem:
         none
      used:
         0
   /vagrant:
      ----------
      1K-blocks:
         303114632
      available:
         252331440
      capacity:
         17%
      filesystem:
         none
      used:
         50783192
minion2:
   ----------
   /:
      ----------
      1K-blocks:
         41251136
      available:
         37852804
      capacity:
         5%
      filesystem:
         /dev/sda1
      used:
         1662420
   /dev:
      ----------
      1K-blocks:
         503908
      available:
         503896
      capacity:
         1%
      filesystem:
         udev
      used:
         12
   /run:
      ----------
      1K-blocks:
         101780
      available:
         101412
      capacity:
         1%
      filesystem:
         tmpfs
      used:
         368
   /run/lock:
      ----------
      1K-blocks:
         5120
      available:
         5120
      capacity:
         0%
      filesystem:
         none
      used:
         0
   /run/shm:
      ----------
      1K-blocks:
         508884
      available:
         508872
      capacity:
         1%
      filesystem:
         none
      used:
         12
   /run/user:
      ----------
      1K-blocks:
         102400
      available:
         102400
      capacity:
         0%
      filesystem:
         none
      used:
            0
   /sys/fs/cgroup:
      ----------
      1K-blocks:
         4
      available:
         4
      capacity:
         0%
      filesystem:
         none
      used:
         0
   /vagrant:
      ----------
      1K-blocks:
         303114632
      available:
         252331440
      capacity:
         17%
      filesystem:
         none
      used:
         50783192

Antarmuka Jaringan

Salt menyediakan modul terpisah, jaringan dan fungsi, antarmuka di dalam modul untuk menanyakan informasi antarmuka jaringan tentang sistem yang dikelola.

salt '*' network.interfaces

Ini akan menghasilkan yang berikut ini output -

minion1:
   ----------
   eth0:
      ----------
      hwaddr:
         08:00:27:04:3e:28
      inet:
         |_
            ----------
            address:
               10.0.2.15
            broadcast:
               10.0.2.255
            label:
               eth0
            netmask:
               255.255.255.0
      inet6:
         |_
            ----------
            address:
               fe80::a00:27ff:fe04:3e28
            prefixlen:
               64
            scope:
               link
      up:
         True
   eth1:
      ----------
      hwaddr:
         08:00:27:34:10:52
      inet:
         |_
            ----------
            address:
               192.168.50.11
            broadcast:
               192.168.50.255
            label:
               eth1
            netmask:
               255.255.255.0
      inet6:
         |_
            ----------
            address:
               fe80::a00:27ff:fe34:1052
            prefixlen:
               64
            scope:
               link
      up:
         True
   lo:
      ----------
      hwaddr:
         00:00:00:00:00:00
      inet:
         |_
            ----------
            address:
               127.0.0.1
            broadcast:
               None
            label:
               lo
            netmask:
               255.0.0.0
      inet6:
         |_
            ----------
            address:
               ::1
            prefixlen:
               128
            scope:
               host
      up:
         True
minion2:
   ----------
   eth0:
      ----------
      hwaddr:
         08:00:27:04:3e:28
      inet:
         |_
            ----------
            address:
               10.0.2.15
            broadcast:
               10.0.2.255
            label:
               eth0
            netmask:
               255.255.255.0
      inet6:
         |_
            ----------
            address:
               fe80::a00:27ff:fe04:3e28
            prefixlen:
               64
            scope:
               link
      up:
         True
   eth1:
      ----------
      hwaddr:
         08:00:27:a7:31:8e
      inet:
         |_
            ----------
            address:
               192.168.50.12
            broadcast:
               192.168.50.255
            label:
               eth1
            netmask:
               255.255.255.0
      inet6:
         |_
            ----------
            address:
               fe80::a00:27ff:fea7:318e
            prefixlen:
               64
            scope:
               link
      up:
         True
   lo:
      ----------
      hwaddr:
         00:00:00:00:00:00
      inet:
         |_
            ----------
            address:
               127.0.0.1
            broadcast:
               None
            label:
               lo
            netmask:
               255.0.0.0
      inet6:
         |_
            ----------
            address:
               ::1
            prefixlen:
               128
            scope:
               host
      up:
         True

Modul Eksekusi sys.doc

Fungsi garam dapat dikirim ke sys.docmodul eksekusi. Ini digunakan untuk mendapatkan detail tentang modul apa pun langsung dari baris perintah. Fungsi Salt mendokumentasikan dirinya sendiri. Semua dokumentasi fungsi bisa diambil dari minion melalui fungsi sys.doc (), yang didefinisikan di bawah ini.

salt '*' sys.doc

Argumen untuk Panggilan Fungsi

Argumen digunakan untuk menyediakan data tambahan untuk pemanggilan fungsi. Contoh argumen sederhana diberikan di bawah ini.

salt '*' sys.doc pkg.install

Di sini, argumennya pkg.install adalah modul untuk menginstal paket tertentu.

Fungsi Python

Argumen adalah parameter yang dipisahkan spasi untuk fungsi tersebut. Ini memungkinkan kode python untuk diteruskan sebagai argumen seperti yang diberikan di bawah ini.

salt '*' cmd.exec_code python 'import sys;print sys.version'

Ini akan menghasilkan yang berikut ini output -

minion2:
   2.7.6 (default, Oct 26 2016, 20:30:19) 
   [GCC 4.8.4]
minion1:
   2.7.6 (default, Oct 26 2016, 20:30:19) 
   [GCC 4.8.4]

Demikian pula, Anda dapat menggunakan kata kunci opsional dan YAML format juga.

Manajemen konfigurasi adalah salah satu konsep paling signifikan di SaltStack. Ini digunakan untuk membuat template konfigurasi yang dapat digunakan kembali, yang disebutstate. Status menjelaskan semua yang diperlukan untuk menempatkan komponen sistem atau aplikasi ke dalam konfigurasi yang diketahui.

Negara Bagian Garam

Status garam adalah konfigurasi yang dapat digunakan kembali untuk bagian tertentu dari suatu sistem. Status lebih mudah dipahami dan dijelaskan menggunakan YAML sederhana.

Buat Negara Garam

Status garam mudah dibuat. Mari kita buat keadaan sederhana di bab ini. Pindah ke direktori “salt-vagrant-demo / saltstack / salt /” dan buat file bernamasamples.sls dan tambahkan baris berikut di dalamnya.

samples.sls

install_network_packages:
   pkg.installed:
      - pkgs:
         - rsync
         - lftp
         - curl

Sekarang, simpan file dan jalankan perintah berikut di master Salt.

root@saltmaster:/home/vagrant# salt 'minion1’ state.apply samples

Di sini, kami menginstal rsync, lftp dan curl melalui pkg.installed modul menggunakan status Salt di minion garam, minion1. Jika berfungsi dengan baik, Anda dapat melihat respons seperti yang ditunjukkan di bawah ini.

Ini akan menghasilkan yang berikut ini output -

minion1:
----------
   ID: install_network_packages
   Function: pkg.installed
   Result: True
   Comment: All specified packages are already installed
   Started: 08:08:48.612336
   Duration: 545.385 ms
   Changes:

Summary for minion1
------------
Succeeded: 1
Failed:    0
------------
Total states run:     1
Total run time: 545.385 ms

Terapkan Salt State

Sekarang kita telah membuat status menggunakan file '.sls' dan menerapkannya dengan memanggilnya secara khusus. Salt memiliki file status default yang disebut sebagaitop.slsmengajukan. File teratas digunakan untuk menerapkan beberapa file status ke pelayan Salt. File teratas menjelaskan di mana negara harus diterapkan. Baik,States dan Top file bekerja sama untuk membuat inti dari kemampuan manajemen konfigurasi SaltStack.

Sekarang mari kita buat file top.sls sederhana di direktori saltstack/salt dan tambahkan yang berikut ini.

top.sls

base:
  '*':
      - common
   'minion1':
      - samples

Di sini state, biasanya applies untuk all system negara, samples berlaku untuk minion1.

Selanjutnya, jalankan master Salt dan terapkan status seperti yang ditunjukkan di bawah ini.

root@saltmaster:/home/vagrant# salt '*' state.apply

Ini akan menghasilkan yang berikut ini output -

minion1:
----------
   ID: common_packages
   Function: pkg.installed
   Result: True
   Comment: All specified packages are already installed
   Started: 09:33:35.642355
   Duration: 588.21 ms
   Changes:

Summary for minion1
------------
Succeeded: 1
Failed:    0
------------
Total states run:     1
Total run time: 588.210 ms
minion2:
----------
   ID: common_packages
   Function: pkg.installed
   Result: True
   Comment: All specified packages are already installed
   Started: 09:33:35.890331
   Duration: 602.79 ms
   Changes:

Summary for minion2
------------
Succeeded: 1
Failed:    0
------------
Total states run:     1
Total run time: 602.790 ms

Terapkan Ukuran Batch

Jika Anda memiliki banyak minion yang terhubung, Anda dapat membatasi berapa banyak sistem yang diperbarui sekaligus. Ini dilakukan dengan menggunakan–batch-size opsi, yang ditentukan di bawah ini.

root@saltmaster:/home/vagrant# salt --batch-size 5 '*' state.apply

Ini akan menghasilkan yang berikut ini output -

Executing run on ['minion2', 'minion1']
jid:
   20170314094638482664
minion1:
----------
   ID: common_packages
   Function: pkg.installed
   Result: True
   Comment: All specified packages are already installed
   Started: 09:46:41.228519
   Duration: 582.24 ms
   Changes:

Summary for minion1
------------
Succeeded: 1
Failed:    0
------------
Total states run:     1
Total run time: 582.240 ms
retcode:
   0
jid:
   20170314094638482664
minion2:
----------
   ID: common_packages
   Function: pkg.installed
   Result: True
   Comment: All specified packages are already installed
   Started: 09:46:41.153609
   Duration: 605.235 ms
   Changes:

Summary for minion2
------------
Succeeded: 1
Failed:    0
------------
Total states run:     1
Total run time: 605.235 ms
retcode:
   0

Fungsi Negara Garam

Fungsi keadaan garam digunakan untuk menginstal dan mengkonfigurasi aplikasi pada sistem jarak jauh Anda. Mari kita instal paket "Vim" menggunakan fungsi status Salt.

Buat dan Terapkan Fungsi Negara

Buat file bernama "sample.sls" di bawah direktori "salt-vagrant-demo / saltstack / salt / sample.sls" dan tambahkan baris berikut -

sample.sls

install vim:
   pkg.installed:
      - name: vim

Setelah, lingkungan Vagrant sudah aktif, jalankan master garam dan terapkan sample.sls dengan menjalankan perintah berikut.

root@saltmaster:/home/vagrant# sudo salt 'minion2’ state.apply sample

Ini akan menghasilkan yang berikut ini output -

minion2:
----------
   ID: install vim
   Function: pkg.installed
   Name: vim
   Result: True
   Comment: Package vim is installed
   Started: 15:07:45.752764
   Duration: 553.506 ms
   Changes:

Summary for minion2
------------
Succeeded: 1
Failed:    0
------------
Total states run:     1
Total run time: 553.506 ms

Sekarang, kami telah menambahkan paket "Vim". Mari kita sekarang menguji paket menggunakan metode pengujian Salt.

Pengujian Status Garam

Uji coba diamanatkan dengan menambahkan opsi "test = True" ke status. Informasi pengembalian akan menunjukkan status yang akan diterapkan dengan warna kuning dan hasilnya dilaporkan sebagai 'Tidak Ada'.

Perintah berikut digunakan untuk menguji status -

root@saltmaster:/home/vagrant# sudo salt 'minion2’ state.apply sample test = True

Ini akan menghasilkan yang berikut ini output -

minion2:
----------
   ID: install vim
   Function: pkg.installed
   Name: vim
   Result: True
   Comment: Package vim is already installed
   Started: 15:07:45.752764
   Duration: 553.506 ms
   Changes:

Summary for minion2
------------
Succeeded: 1
Failed:    0
------------
Total states run:     1
Total run time: 553.506 ms

SaltStack ─ Komponen Pilar

Pilar adalah komponen penting untuk membuat status Salt dapat digunakan kembali. Ini digunakan untuk menentukan data aman untuk antek yang ditugaskan menggunakan target. Data pilar garam menyimpan nilai seperti port, jalur file, parameter konfigurasi, dan kata sandi.

File konfigurasi pilar

Konfigurasi untuk pillar_roots di file konfigurasi utama ditunjukkan di bawah ini -

pillar_roots:
   base:
      - /srv/pillar

Di sini, file tersebut ada di direktori “/ srv / pillar”.

Pertimbangkan, file teratas yang terletak di /srv/pillar/top.sls memiliki struktur berikut -

base:
   '*':
      - default

Sekarang, pindah ke file default.sls yang terletak di /srv/pillar/default.sls dan tambahkan kode berikut.

# Default pillar values
apache
git

Setelah menyimpan file, segarkan pilar untuk memperbarui semua perubahan.

Menyegarkan Pilar

Anda dapat menyegarkan pilar menggunakan perintah berikut.

root@saltmaster:/home/vagrant# salt '*' saltutil.refresh_pillar

Perintah di atas digunakan untuk menyegarkan data pilar Salt di semua minion.

Buat Daftar Data Pilar

Untuk membuat daftar data pilar, Anda dapat menggunakan perintah yang diberikan di bawah ini.

root@saltmaster:/home/vagrant# salt '*' pillar.ls

Ini akan menghasilkan yang berikut ini output -

minion2:
   - apache
   - git
minion1:
   - apache
   - git

Item Pilar

Setelah pilar diatur, data dapat dilihat pada minion melalui modul pilar. Itu dapat diakses melalui fungsipillar.items, yang dijelaskan di bawah.

root@saltmaster:/home/vagrant# salt '*' pillar.items

Ini akan menghasilkan yang berikut ini output -

minion2:
   ----------
   apache:
      httpd
   git:
      git
minion1:
   ----------
   apache:
      httpd
   git:
      git

SaltStack - Sertakan Komponen

Komponen 'Include' digunakan untuk menentukan tugas konfigurasi yang sama di banyak tempat. Mudah dilakukan. Di bagian atas file negara Anda, tambahkan penyertaan menggunakan format berikut -

include:
   - state file 1 
   - state file 2

Sini, state file 1 dan state file 2adalah nama file SLS yang ingin Anda sertakan. Tidak perlu menyertakan.slsperpanjangan. Status Garam yang Disertakan disisipkan di bagian atas file saat ini.

Status File di Subdirectory

Anda dapat menyertakan file status subdirektori menggunakan titik (.). Bertindak sebagai pemisah direktori.

include:
   - dir.sls1

Antarmuka Biji-bijian

Biji-bijian adalah antarmuka yang digunakan untuk memperoleh informasi tentang sistem yang mendasarinya. Butir dikumpulkan untuk sistem operasi, nama domain, alamat IP, kernel, jenis OS, memori, dan banyak properti sistem lainnya.

Penargetan Biji-bijian

Data butir dapat digunakan saat menargetkan antek, yang ditentukan di blok kode berikut.

root@saltmaster:/home/vagrant# salt -G 'os:Ubuntu' test.ping

Ini akan menghasilkan yang berikut ini output -

minion1:
   True
minion2:
   True

Daftar Biji-bijian

Biji-bijian dapat dicantumkan dengan menggunakan modul 'grains.ls', yang dijelaskan di bawah.

root@saltmaster:/home/vagrant# salt '*' grains.ls

Daftar item

Seperti Pillar, data Grains juga dapat didaftarkan dengan menggunakan 'grains.items'.

root@saltmaster:/home/vagrant# salt '*' grains.items

Logging digunakan untuk melacak aktivitas perangkat lunak yang sedang berjalan. Peristiwa dijelaskan dengan pesan deskriptif, yang secara opsional dapat berisi data variabel. Pendekatan penebangan garam digunakan untuk mendapatkan masalah apa pun, yang mungkin Anda hadapi. Anda dapat memeriksa dengan level log tertentu.

Pengaturan konfigurasi

Biarkan kami memahami pengaturan konfigurasi yang berbeda untuk logging, secara detail.

LOG_FILE

Catatan log garam melewati file, yang berisi nama jalur lokal atau lokasi jaringan untuk identifikasi. File ini dianggap sebagai file log.

log_file: /var/log/salt/master

Di sini, file yang bergantung pada biner dieksekusi di master. Demikian pula, Anda juga dapat mengeksekusi di minion, yang ditunjukkan di bawah ini.

log_file: /var/log/salt/minion

Anda juga dapat menggunakan alamat jarak jauh. Sintaks untuk menggunakan alamat jarak jauh adalah - <file | udp | tcp>: // <host | socketpath>: <port-if-required> / <log-facility>.

log_file: udp://loghost:port

Di sini, fasilitas Log secara default adalah LOG_USER.

LOG_LEVEL

Tingkat log diurutkan dalam nilai yang ditetapkan secara numerik. Library Python telah mendefinisikan sebagian besar level logging secara default. Selain itu, Salt menggunakan beberapa level lagi. Beberapa level dijelaskan di bawah ini.

log_level: error; level value is 40 - Ini menunjukkan catatan pernyataan log pada kesalahan.
log_level: quiet; level value is 1000 - Ini menunjukkan bahwa tidak ada yang harus dicatat pada level ini.
log_level: info; level value is 20 - Ini menunjukkan informasi log normal.
log_level: warn; level value is 30 - Ini menunjukkan catatan pernyataan log pada peringatan.
log_level: debug; level value is 10 - Informasi yang berguna untuk men-debug implementasi salt dan kode salt.
log_level: trace; level value is 5 - Informasi kode-debugging yang lebih detail.

LOG_LEVEL_LOGFILE

Ini menentukan tingkat pesan untuk dikirim ke file log.

log_level_logfile: info

LOG_DATEFMT

Ini mendefinisikan format tanggal log. Secara default, ini direpresentasikan sebagai% Y-% m-% d% H:% M:% S.

log_datefmt_logfile: '%Y-%m-%d %H:%M:%S'

LOG_FMT_CONSOLE

Ini mendefinisikan format konsol yang mencatat pesan. Garam menggunakan kebiasaanLogRecordatribut untuk mewarnai keluaran log konsol. Ini mengikuti sintaks berikut -

'%(colorlevel)s'       # log level name colorized by level
'%(colorname)s'        # colorized module name
'%(colorprocess)s'     # colorized process number
'%(colormsg)s'         # colorized messages name

LOG_FMT_LOGFILE

Ini mendefinisikan format file log yang mencatat pesan. Sintaks dasarnya adalah sebagai berikut -

%(asctime)s,%(msecs)03d [%(name)-17s][%(levelname)-8s] %(message)s

LOG_GRANULAR_LEVELS

Level ini digunakan untuk mengontrol level logging secara lebih spesifik.

log_granular_levels:
   'salt': 'info'
   'salt.modules': ‘trace'

Di sini, pustaka garam Utama di tingkat 'info' menyetel salt.modules untuk mencatat di tingkat jejak.

Penangan Log Eksternal

Salt menggunakan LogStash dan penangan log eksternal Sentry untuk logging. Mari kita pahami secara detail di bab ini.

Penangan LOGSTASH

LogStash adalah open source; pipeline pemrosesan data aman sisi server. Mari kita pertimbangkan handler logging UDP sederhana di Salt yang menggunakan LogStash.

Tentukan perubahan berikut dalam file master Salt -

logstash_udp_handler:
   host: 127.0.0.1
   port: 9999
   version: 1
   msg_type: logstash

Kemudian tambahkan perubahan di file konfigurasi Logstash -

input {
   udp {
      port ⇒ 9999
      codec ⇒ json
   }
}

Sini, UDP - adalah masukan yang harus memiliki format sebagai json_event, itulah yang kami kirimkan melalui kawat.

SENTRY Logging Handler

Sentry adalah pelacakan kesalahan waktu nyata dalam penerapan produksi dan informasi untuk mereproduksi dan memperbaiki kerusakan. Konfigurasi default di file master ditentukan di bawah ini.

sentry_handler:
   dsn: https://pub-key:[email protected]/app-id
   log_level: debug

Di sini, level logging default untuk sentry handler adalah ERROR, tetapi kami mendefinisikan debug log_level di bawah kunci konfigurasi sentry_handler.

Salt menjalankan perintah di sistem jarak jauh dengan menggunakan salt-minion. Ini adalah perilaku normal. Dalam beberapa skenario, sistem jarak jauh hanya dapat diakses oleh protokol SSH. Untuk skenario ini, Salt memberikan opsi untuk menghubungkan sistem jarak jauh hanya menggunakan protokol SSH dan menjalankan perintah melalui lapisan SSH.

Salt SSHsangat mudah dikonfigurasi. Satu-satunya konfigurasi yang diperlukan adalah menentukan detail sistem jarak jauh dalam file khusus yang disebut sebagaiRoster file. File daftar ini biasanya terletak di/etc/salt/roster. File daftar akan memiliki semua informasi mengenai sistem jarak jauh dan bagaimana kita dapat terhubung dengannya. Setelah file daftar dikonfigurasi, semua perintah Salt dijalankan menggunakan filesalt-ssh alih-alih perintah garam.

File Daftar

Sistem Roster dirancang khusus untuk Salt SSH. Ini dirancang sebagai sistem yang dapat dicolokkan. Satu-satunya tujuan dari sistem daftar adalah untuk mengumpulkan informasi tentang sistem jarak jauh. File daftar nama adalahYAML based configuration file berisi informasi sistem jarak jauh sebagai targets. Target ini adalah struktur data khusus dengan sekumpulan atribut yang telah ditentukan sebelumnya. File daftar berisi satu atau lebih target dan setiap target diidentifikasi oleh aSalt ID.

Struktur dasar file daftar adalah sebagai berikut -

<Salt ID>:
   host: <host name>
   user: <user name>
   passwd: <password of the user>

Semua atribut lain yang didukung oleh file daftar adalah opsional. Mereka adalah sebagai berikut -

port - Nomor port SSH.
sudo - apakah akan menjalankan perintah melalui sudo.
sudo_user - nama pengguna sudo.
tty - benar jika sudo diaktifkan.
priv - kunci pribadi.
timeout - batas waktu untuk koneksi SSH.
minion_opts - kamus pilihan antek.
thin_dir - direktori penyimpanan sistem target untuk komponen garam.
cmd_umask - umask untuk memaksa perintah salt-call.

Contoh file daftar nama adalah sebagai berikut -

web:
   host: 192.168.2.1
   user: webuser
   passwd: secret
   sudo: True   
db:
   host: 192.168.2.2

Terapkan Kunci SSH

Salt SSH akan menghasilkan pasangan kunci publik / pribadi default untuk login SSH. Path defaultnya adalah /etc/salt/pki/master/ssh/salt-ssh.rsa. Kunci ini dapat digunakan ke sistem jarak jauh menggunakanssh-copy-id perintah seperti yang ditunjukkan di bawah ini.

ssh-copy-id -i /etc/salt/pki/master/ssh/salt-ssh.rsa.pub [email protected]

Jalankan Perintah

Menjalankan perintah garam semudah mengubah salt cli perintah ke salt-ssh seperti gambar dibawah.

salt-ssh '*' test.ping

Perintah Shell Mentah

Salt SSH menyediakan opsi (-r) untuk menjalankan perintah mentah di sistem jarak jauh dengan melewati modul dan fungsi garam.

salt-ssh '*' -r 'ls'

Menargetkan dengan Salt SSH

Menargetkan sistem jarak jauh di Salt SSH hanya mendukung target glob dan regex. Karena Salt SSH adalah modul terpisah, ia hanya menyediakan opsi terbatas seperti saat ini dan akan menyediakan lebih banyak fitur dalam waktu dekat.

Salt menyediakan modul terpisah, Salt Cloud untuk menyediakan mesin virtual dari berbagai penyedia cloud seperti Amazon AWS, Google Compute, dll. Salt Cloud adalah antarmuka umum untuk mengonfigurasi dan mengelola VM dari berbagai penyedia cloud.

Cloud Config- File konfigurasi utama untuk Salt Cloud adalah / etc / salt / cloud dan ini berlaku untuk semua VM. File konfigurasi utama dipanggilCloud Config.
Cloud Providers - Untuk menargetkan penyedia cloud tertentu, kita dapat menggunakan file konfigurasi tertentu dan mereka berada di /etc/salt/cloud.providers.d/*.conf, ini disebut sebagai Cloud Providers.
Cloud Profiles - Untuk menargetkan VM tertentu, kita juga dapat menggunakan file konfigurasi khusus, yang berlaku hanya untuk VM tersebut dan terletak di /etc/salt/cloud.profiles.d/*.conf, ini disebut sebagai Cloud Profiles.

Untuk mesin virtual, pengaturan di Cloud Config diterapkan terlebih dahulu dan kemudian di Cloud Providers dan akhirnya penggantian dilakukan oleh Cloud Profiles.

Pemasangan Salt Cloud

Secara default, Salt Cloud dibangun ke dalam Salt dan sudah tersedia. Jika tidak tersedia, kita bisa menginstalnya dengan menggunakan perintah di bawah ini.

pip install salt-cloud

Karena Salt Cloud adalah modul terpisah dan berjalan dalam prosesnya sendiri, itu dapat diinstal di sistem Salt Minion juga sebagai ganti Salt Master.

Menyediakan Mesin Virtual

Untuk menyediakan mesin virtual, kita perlu menentukan penyedia cloud dan profil cloud. Setelah keduanya dibuat, kami dapat menyediakan mesin virtual baru untuk menggunakannya.

Penyedia Cloud

Informasi host cloud dikonfigurasi di file konfigurasi penyedia Cloud. Biasanya, informasi dasar, yang perlu dikonfigurasi adalah driver cloud, nama pengguna, kata sandi, kunci pribadi, dll. Mari kita buat penyedia cloud baru bernama sebagaimy-amazon-cloud.

Buat file, my-amazon-cloud.conf di bawah /etc/salt/cloud.providers.d/
Tambahkan penyedia baru menggunakan ec2 sopir.

my-amazon-cloud:
   driver: ec2
   id: '<AWS_ID>'
   key: '<AWS_KEY>'
   private_key: /path/to/privatekey.pem
   keyname: <name of the key>
   securitygroup: default

   minion:
      master: <master server>

Salt menyediakan driver untuk berbagai host cloud di luar kotak, seperti GoGrid, HP Cloud, Google Compute Engine (GCE), Amazon AWS, Joyent, Linode, OpenNebula, ProfitBricks, Proxmox, Saltify, VexxHost, VMWare, dll.

Setelah penyedia cloud dikonfigurasi, kami dapat menanyakan lokasi penyedia yang tersedia, image mesin yang tersedia, dan berbagai ukurannya.

salt-cloud --list-location my-amazon-cloud
salt-cloud --list-images my-amazon-cloud
salt-cloud --list-sizes my-amazon-cloud

Profil Cloud

Profil Cloud menentukan gambar dan ukuran mesin virtual. Ini dapat dikonfigurasi di - /etc/salt/cloud.profiles.d/. Mari kita buat profil sederhana,simple.conf.

aws_micro:
   provider: my-amazon-cloud
   image: <image_id>
   size: <machine_id e.g. t1.micro>

Mesin virtual

Setelah penyedia dan profil dikonfigurasi, kami dapat dengan mudah menyediakan mesin virtual menggunakan cloud garam seperti yang ditunjukkan di bawah ini.

salt-cloud -p aws_micro master minion1 minion2

Dimana, p - Master nama profil, minion1 dan minion2 adalah mesin virtual baru.

Detail mesin virtual yang baru dibuat dapat diperoleh dengan menggunakan perintah berikut.

salt-cloud --query

Mesin virtual dapat dihancurkan menggunakan perintah berikut -

slat-cloud -d master minion1

Cloud Map

Cloud Map adalah format khusus untuk membuat beberapa mesin virtual sekaligus. Format file peta adalah untuk menentukan profil dan kemudian menambahkan daftar mesin virtual di bawahnya.

Contoh file peta adalah sebagai berikut -

micro:
   - web1
   - web2
large:
   - db1
   - db2

File peta dapat diteruskan sebagai argumen ke perintah salt-cloud untuk membuat mesin virtual sebagai berikut -

salt-cloud -m /path/to/mapfile

Ada banyak perangkat seperti router, perlengkapan jaringan, dll., Yang memiliki OS khusus, memori terbatas, dan pertimbangan keamanan yang tinggi. Di perangkat tersebut, kami tidak dapat menginstal standarsalt-miniondan selanjutnya tidak dapat mengelola sistem tersebut. Namun, Salt memberikan teknologi inovatif untuk mengatasi kendala tersebut.

Salt memiliki modul terpisah, minion proxy garam yang mengontrol sistem jarak jauh menggunakan layanan REST yang berjalan di sistem jarak jauh. Layanan REST ini adalah layanan web berbasis HTTP yang ditulis menggunakanRepresentational State Transfer (REST) konsep dan keduanya mudah diterapkan dan mudah dikonsumsi.

Setiap perangkat akan memiliki SDK dan lingkungan pengembangannya sendiri untuk menulis aplikasi yang kompleks. Salt mengharapkan layanan REST dikembangkan di perangkat sesuai spesifikasi antarmuka Salt. Salt juga menyediakan modul python untuk menulis layanan web REST. Jika perangkat mendukung python, maka akan mudah untuk mengembangkan layanan web REST.

Setelah layanan web REST dikembangkan dan diterapkan di sistem jarak jauh, Salt dapat dikonfigurasi untuk mengontrol perangkat jarak jauh menggunakan layanan web REST alih-alih minion garam.

Contoh Kerja

Mari kita pelajari konsep salt proxy minionmenggunakan lingkungan kerja langsung. Untuk lingkungan langsung, kami memilih sistem Linux untuk master dan minion proxy. Kami akan mengontrol sistem menggunakan layanan web REST daripada salt-minion.

Instal dan Konfigurasi Layanan Web REST

Salt memberikan contoh implementasi layanan web REST, yang dinamai proxyminion_rest_example dalam modul kontribusinya. Mari kita instal layanan web sampel.

Install ‘bottle’menggunakan pip. Itubottle Perintah adalah kerangka kerja web python untuk mengembangkan aplikasi web.

pip install bottle = 0.12.8

Unduh saltstack/salt-contribproyek dari github. Jika tidak, gandakan proyek menggunakan perintah berikut.

git clone https://github.com/saltstack/salt-contrib

Buka terminal dan pergi ke salt-contrib direktori.
Direktori salt-contrib ini akan memiliki folder, proxyminion_rest_example. Folder ini berisi contoh implementasi untuk layanan web REST. Buka folder proxyminion_rest_example.
Jalankan perintah berikut untuk memulai layanan web REST.

python rest.py --address <your ip address> --port 8000

Buka browser dan muat http: // «alamat ip Anda»: 8000. Ini akan menampilkan halaman default dengan layanan dan paket seperti yang ditunjukkan pada gambar di bawah.

Sekarang, kami telah mengonfigurasi layanan web REST dan itu akan memeriksa cara mengkonfigurasi proxy garam untuk menanyakan layanan web REST dan mengontrol sistem.

Konfigurasikan Salt-Proxy

Untuk mengkonfigurasi Salt-Proxy, kita harus mengikuti langkah-langkah yang diberikan di bawah ini.

Kita harus menentukan node master untuk salt-proxy. Edit lokasi file konfigurasi proxy, yaitu di / etc / salt / proxy, dan masukkan kode berikut.

master: <your ip address>

Ubah / buat file pilar dasar di /srv/pillar/top.sls seperti yang ditunjukkan pada blok kode berikut.

base:
  'p8000':
      - p8000

Tambahkan file pilar baru, p8000.sls dalam /srv/pillar seperti yang ditunjukkan pada blok kode di bawah ini.

proxy:
   proxytype: rest_sample
   url: http://<your ip address>:8000

Mulai salt-proxy dalam mode debug menggunakan perintah berikut.

salt-proxy --proxyid = p8000 -l debug

Mirip dengan garam-minion, terima salt-proxy key seperti gambar dibawah.

salt-key -y -a p8000

The following keys are going to be accepted:
Unaccepted Keys:
p8000
Key for minion p8000 accepted.

Menjalankan Salt

Sekarang, jalankan salt perintah dan panggil ping.test berfungsi seperti yang ditunjukkan di bawah ini.

salt p8000 test.ping

Kami dapat menjalankan fungsi apa pun yang didukung oleh layanan web REST dengan menggunakan salt, yang mirip dengan salt-minion.

Misalnya, informasi butir dapat diperoleh dengan menggunakan perintah berikut.

salt p8000 grains.items

Sistem acara di Salt adalah antarmuka PUB ZeroMQ lokal, yang mengaktifkan acara garam. Ini dilakukan oleh komponen berikut.

Event Sockets - Digunakan untuk mempublikasikan acara.
Event library - Digunakan untuk mendengarkan acara dan mengirim acara ke sistem garam.

Acara Salt Master

Seorang master garam menyediakan berbagai jenis acara, yang dijelaskan secara rinci di bawah -

Peristiwa otentikasi
Mulai acara
Peristiwa penting
Acara pekerjaan
Acara Pelari
Acara Kehadiran
Acara Cloud

Mari kita bahas setiap jenis acara secara mendetail.

Peristiwa Otentikasi

Peristiwa otentikasi ini terjadi ketika antek melakukan pemeriksaan otentikasi dengan master. Ini diwakili oleh salt / auth.

Mulai Acara

Peristiwa start dijalankan setiap kali minion terhubung ke master Salt dan diwakili oleh salt / minion // start.

Peristiwa Penting

Peristiwa kunci dijalankan ketika master garam menerima dan menolak kunci di minion Salt. Anda dapat mengakses acara ini menggunakan perintah salt-key.

Acara Pekerjaan

Acara Pekerjaan dipecat setiap kali pekerjaan baru akan dimulai. Itu diwakili olehsalt/job//new. Disini, JID - Job id new - new job

Acara Pelari

Ketika seorang pelari mulai mengeksekusi, peristiwa pelari dipecat. Ini diwakili oleh salt / run // new.

Acara Kehadiran

Saat minion terhubung atau baru saja terhubung atau terputus, acara ini dijalankan secara berkala. Itu diwakili oleh -salt/presence/present dan salt/presence/change. Sini,

Present - berarti master Salt saat ini terhubung ke daftar minion.
Change - digunakan untuk mendeteksi antek baru - terhubung atau terputus.

Acara Cloud

Peristiwa awan garam dijalankan pada mesin virtual. Kecuali acara lain, itu tidak dilakukan di minion. Anda dapat mengaksesnya menggunakan -salt/cloud//creating. Itu diaktifkan ketika awan Salt memulai proses eksekusi mesin virtual.

Alat Acara

Sekarang, mari kita lihat alat dan skrip acara. Anda dapat mengakses bus acara menggunakan CLI. Itu diakses dengan perintah berikut.

salt-run state.event pretty = True

Di sini, runner dirancang untuk berinteraksi dengan bus peristiwa dari alat eksternal dan skrip shell. Bus acara Salt dapat diakses dari jarak jauh melaluiREST API. Ini diwakili oleh - (contoh URL).

curl -SsNk https://salt-api.example.com:8000/events?token = 05A3.

Demikian pula, Anda juga dapat mengakses acara dari skrip Python.

Secara umum, orchestrationadalah koordinasi otomatis dan pengaturan sistem. Orchestrate runner digunakan untuk melakukan orkestrasi di SaltStack.

Atur Pelari

dia Orchestrate Runner menawarkan semua fungsionalitas file OverState(sistem sebelumnya). Ini awalnya disebut sebagaistate.slspelari. Pelari orkestrasi ini digunakan untuk menggeneralisasi sistem status Salt ke konteks master Salt.

Itu state.sls dan state.highstate fungsi dijalankan pada setiap minion Salt, tetapi state.orchestratepelari dieksekusi pada master. Itustate.orchestraterunner memungkinkan Anda untuk mengelola seluruh infrastruktur Anda sebagai negara sepenuhnya. Mari kita pahami bagaimana melalui proses eksekusi sederhana.

Eksekusi Sederhana

Perintah Orchestrate Runner sama dengan state.sls fungsi, tetapi Anda dapat menjalankannya dengan "salt-run" sebagai ganti salt.

Asumsikan bahwa Anda memiliki file sample.sls file terletak di /srv/salt/orch/samples.sls. Tambahkan kode berikut di file itu.

sample.sls

install_nginx:
   salt.state:
      - tgt: 'web*'
      - sls:
         - nginx

Perintah berikut digunakan untuk menjalankan master dan ini akan menerapkan status yang ditentukan dalam file itu.

salt-run state.orchestrate orch.sample

Ini akan menghasilkan yang berikut ini output -

saltmaster.local_master:
----------
   ID: install_nginx
   Function: salt.state
   Result: True
   Comment: States ran successfully.
   Started: 11:54:56.308078
   Duration: 63.401 ms
   Changes:

Summary for saltmaster.local_master
------------
Succeeded: 1
Failed:    0
------------
Total states run:     1
Total run time:  63.401 ms
root@saltmaster:/home/vagrant#

Di sini, menurut Versi Saat Ini, fungsi runner diubah namanya menjadi state.orchestrate. Ini akan membantu untuk menghindari kebingungan dengan fungsi eksekusi state.sls, tetapi versi sebelumnya daristate.sls harus digunakan.

Jalankan Fungsi

Untuk menjalankan suatu fungsi, Anda harus menggunakan salt.function. Pertimbangkan sebuah filedata.sls berlokasi di /srv/salt/orch/data.sls. Sekarang, tambahkan perubahan berikut di file itu.

data.sls

cmd.run:
   salt.function:
      - tgt: '*'
      - arg:
         - rm -rf /tmp/data

Perintah berikut digunakan untuk menjalankan fungsi Salt.

root@saltmaster:/home/vagrant# salt-run state.orchestrate orch.data

Ini akan menghasilkan yang berikut ini output -

saltmaster.local_master:
----------
   ID: cmd.run
   Function: salt.function
   Result: True
   Comment: Function ran successfully. Function cmd.run ran on minion1, minion2.
   Started: 12:14:54.791635
   Duration: 234.615 ms
   Changes:
      minion1:

      minion2:
Summary for saltmaster.local_master
------------
Succeeded: 1 (changed = 1)
Failed:    0
------------
Total states run:     1
Total run time: 234.615 ms

Formula garam dikemas dan didistribusikan ke master Salt menggunakan manajer paket. Konsep ini dipengaruhi dariRPM, Yum dan Pacmansistem pengemasan. Status garam, pilar, templat file, dan file lainnya digunakan oleh rumus dan kemudian dikemas menjadi satu file.

Setelah paket rumus dibuat, itu disalin ke Sistem Repositori agar dapat digunakan untuk master Salt. Sebelum pindah ke manajer paket, mari kita lihat cara menginstal paket "nginx" menggunakan perintah dasar Salt.

Sintaks berikut digunakan untuk menginstal paket "nginx".

root@saltmaster:/home/vagrant# salt '*' pkg.install nginx

Di sini pkg.install nginxperintah digunakan untuk menginstal paket. Setelah eksekusi, Anda akan melihat respons berikut.

Ini akan menghasilkan yang berikut ini output -

minion2:
   ----------
   httpd:
      ----------
      new:
         1
      old:
   httpd-cgi:
      ----------
      new:
         1
      old:
   libxslt1.1:
      ----------
      new:
         1.1.28-2build1
      old:
   nginx:
      ----------
      new:
         1.4.6-1ubuntu3.7
      old:
   nginx-common:
      ----------
      new:
         1.4.6-1ubuntu3.7
      old:
   nginx-core:
      ----------
      new:
         1.4.6-1ubuntu3.7
      old:
minion1:
   ----------
   httpd:
      ----------
      new:
         1
      old:
   httpd-cgi:
      ----------
      new:
         1
      old:
   libxslt1.1:
      ----------
      new:
         1.1.28-2build1
      old:
   nginx:
      ----------
      new:
         1.4.6-1ubuntu3.7
      old:
   nginx-common:
      ----------
      new:
         1.4.6-1ubuntu3.7
      old:
   nginx-core:
      ----------
      new:
         1.4.6-1ubuntu3.7
      old:

Sekarang, Anda telah menginstal sebuah paket. Untuk memulai layanan untuk paket itu, gunakan perintah yang diberikan di bawah ini.

root@saltmaster:/home/vagrant# salt '*' service.start nginx

Setelah menjalankan perintah ini, hasilnya terlihat seperti pada blok kode di bawah ini.

minion1:
   True
minion2:
   True

Oleh karena itu, kami telah menginstal dan memulai layanan untuk paket "nginx" menggunakan perintah dasar. Sekarang mari kita bahas bagaimana membangun dan menginstal paket di pengelola paket Salt.

Paket Bangunan

Paket dapat dibuat di sistem apa pun tempat Anda dapat menginstal Salt. Ada tiga jenis paket dan mereka adalah sebagai berikut.

Formula
Reactor
Conf

Sekarang mari kita mengerti bagaimana membangun paket menggunakan Fomula Mengajukan.

File Formula

Sebagian besar file dari paket terletak di direktori - / srv / spm / salt / secara default, tetapi file pilar dapat ditempatkan di direktori - / srv / spm / pillar /. File Formula menjelaskan paket tersebut.

Example

name: apache
os: RedHat
os_family: RedHat
version: 201607
release: 2
summary: Formula for installing Apache
description: Formula for installing Apache

Sini,

Name- Nama paketnya. Di sini, nama paketnya adalahapache.
os - Digunakan untuk mengetahui sistem operasi mana yang dapat mendukung paket ini.
os_family - Ini digunakan untuk mengetahui keluarga sistem operasi mana yang dapat mendukung paket ini.
Version- Versi paket. Ini ditentukan dalam format YYYYMM.
Release - Bidang ini merujuk pada rilis suatu versi.
Summary - Deskripsi paket dengan garis pendek.
Description - Deskripsi paket yang lebih detail.

REAKTOR

File reaktor berada di /srv/spm/reactor/ direktori.

CONF

File-file dalam tipe paket ini adalah file konfigurasi untuk Salt, yang biasanya berada di dalam /etc/salt/direktori. File konfigurasi untuk paket selain Salt dapat dan harus ditangani dengan Salt State (menggunakan jenis rumus paket).

Mari kita lanjutkan dengan langkah-langkah berikut untuk membangun sebuah paket.

Buat file FORMULA dan letakkan di root folder paket.
Kumpulkan file rumus dalam folder di sistem build.
Lari spm build. Paket ini dibangun dan ditempatkan di folder / srv / spm_build. Perintah berikut digunakan untuk membangun sebuah paket.

spm build /path/to/salt-packages-source/formula

Sekarang, salin file .spm file ke folder di sistem repositori.
Anda dapat membagikan srv/spm_build folder di jaringan, atau salin file ke FTP atau server Web Anda.
Hasilkan metadata repo menggunakan perintah berikut.

spm create_repo /srv/spm_build

Menginstal Paket

Bagian ini menjelaskan tentang menginstal paket manajer paket Salt.

Konfigurasi Remote Repositories

Untuk mengonfigurasi repositori jarak jauh, Salt Master perlu mengetahui di mana letak repositori melalui proses konfigurasi.

File ada di /etc/salt/spm.repos.d/spm.repo direktori.

Example

file_repository:
   url: https://spm.example.com/

Di sini, file tersebut berisi nama repositori dan tautan ke repositori. Anda juga dapat menggunakan http, https, ftp, atau jalur file. Untuk menggunakan file path, Anda dapat mengaksesnya menggunakan URL: file: /// srv / spm_build.

Perbarui Metadata

Setelah repositori dikonfigurasi pada master Salt, metadata repositori diunduh menggunakan perintah di bawah ini.

spm update_repo

Perbarui File Roots

Paket SPM terletak di direktori srv / spm / salt. Tambahkan jalur berikut ke file root di master Salt,

file_roots:
   base:
      1. /srv/salt
      2. /srv/spm/salt

Sekarang, mulai ulang master garam.

Instal Paket Apache

Untuk menginstal paket apache, gunakan perintah berikut.

spm install apache

Anda juga dapat menginstal langsung dari file SPM menggunakan perintah di bawah ini.

spm local install /srv/spm/apache-201607-1.spm

Menghapus Paket

Untuk menghapus paket, misalnya - apache, gunakan perintah berikut,

spm remove apache

Perhatikan bahwa, jika ada file yang telah dimodifikasi, file tersebut tidak akan dihapus.

Salt menyediakan akses terprogram ke semua perintahnya. Salt menyediakan modul yang berbeda untuk setiap bagian dari sistem Salt. Mari kita pelajari dasar-dasar API python dan tentang cara menjalankan perintah garam dasar di bab ini.

Konfigurasi

Itu salt.config modul digunakan untuk mengakses detail konfigurasi Salt.

import salt.config
opts = salt.config.client_config('/etc/salt/master')

Di sini client_config membaca file konfigurasi salt dan mengembalikan detail konfigurasi sebagai kamus.

Pemuat

Itu salt.loader module digunakan untuk memuat setiap modul di Salt seperti grain, minions, dll.

import salt.loader
opts = salt.config.minion_config('/etc/salt/minion')
grains = salt.loader.grains(opts)

Sini, grains membaca detail biji-bijian di sistem Salt dan mengembalikannya.

Modul Klien

Itu salt.client modul digunakan untuk menjalankan perintah salt, salt-call, dan salt-SSH secara terprogram.

Kelas python yang paling penting adalah sebagai berikut -

salt.client.LocalClient
salt.client.Caller
salt.client.ssh.client.SSHClient

Fungsi utama yang disediakan oleh sebagian besar modul klien adalah cmd. Fungsi ini membungkus opsi CLI dan menjalankannya, yang mirip dengan baris perintah dan mengembalikan hasilnya sebagai struktur data python.

LocalClient

LocalClient digunakan untuk mengirim perintah dari master ke salt minion dan mengembalikan hasilnya ke master.

import salt.client

local = salt.client.LocalClient()
local.cmd('*', 'test.ping')

Ini akan menghasilkan yang berikut ini output -

{'minion1': True, 'minion2': True }

Penelepon

Penelepon digunakan untuk menjalankan salt-call secara terprogram dan mengembalikan hasilnya.

import salt.client
caller = salt.client.Caller()
caller.cmd('test.ping')

Ini akan menghasilkan yang berikut ini output -

True

SSHClient

SSHCient digunakan untuk menjalankan salt-ssh secara terprogram dan mengembalikan hasilnya.

import salt.client.ssh.client
ssh = salt.client.ssh.client.SSHClient()
ssh.cmd('*', 'test.ping')

Ini akan menghasilkan yang berikut ini output -

{'minion1': True, 'minion2': True }

CloudClient

Modul salt.cloud digunakan untuk menjalankan perintah salt-cloud secara terprogram.

client = salt.cloud.CloudClient(path = '/etc/salt/cloud')

Modul cloud menyediakan fungsi untuk membuat VM (membuat), untuk menghancurkan VM (menghancurkan), daftar gambar yang disediakan oleh penyedia cloud (list_images), daftar lokasi penyedia cloud (list_locations), daftar ukuran mesin dari penyedia cloud (list_sizes), dll.

Dalam contoh kerja ini, kita akan membuat rumus Salt yang akan mengkonfigurasi server web apache bersama dengan perangkat lunak PHP. Salt adalah cara yang bagus untuk menjalankan perintah ad-hoc, tetapi Anda tidak ingin terus-menerus mengkonfigurasi infrastruktur Anda dengan cara ini. Dengan membuat sekumpulan rumus Salt, Anda dapat mereproduksi konfigurasi apa pun dengan andal.

Rumus Salt adalah file teks YAML sederhana dan secara default berada di Salt Master Anda di /srv/salt/*. Mari kita mulai dengan membuat Formula Salt untuk menginstal server web Apache dan PHP secara bersamaan.

Buat file bernama "websetup.sls" di bawah /srv/salt/ direktori dan tambahkan kode berikut.

websetup.sls

websetup:
   pkg:
      - installed
      - pkgs:
         - apache2
         - php5
         - php5-mysql

Dalam contoh ini, perhatikan argumen “- pkgs:”. Setiap item dalam daftar di bawah "- pkgs:" akan diteruskan bersama ke manajer paket OS untuk diinstal bersama. Kapanpun Anda memiliki banyak paket untuk diinstal, ini adalah cara paling efisien untuk menginstalnya.

Terapkan Formula ini ke master Salt menggunakan perintah berikut.

root@saltmaster:/home/vagrant# salt 'minion2' state.sls websetup

Sekarang, Anda akan melihat yang berikut ini output -

minion2:
----------
   ID: websetup
   Function: pkg.installed
   Result: True
   Comment: 3 targeted packages were installed/updated.
   Started: 01:50:53.978396
   Duration: 86738.132 ms
   Changes:
      ----------
         apache2:
            ----------
            new:
               2.4.7-1ubuntu4.13
            old:
         apache2-api-20120211:
            ----------
            new:
               1
            old:
         apache2-bin:
            ----------
            new:
               2.4.7-1ubuntu4.13
            old:
         apache2-data:
            ----------
            new:
               2.4.7-1ubuntu4.13
            old:
         libapache2-mod-php5:
            ----------
            new:
               5.5.9+dfsg-1ubuntu4.21
            old:
         libapr1:
            ----------
            new:
               1.5.0-1
            old:
         libaprutil1:
            ----------
            new:
               1.5.3-1
            old:
         libaprutil1-dbd-sqlite3:
            ----------
            new:
               1.5.3-1
            old:
         libaprutil1-ldap:
            ----------
            new:
               1.5.3-1
            old:
         php5:
            ----------
            new:
               5.5.9+dfsg-1ubuntu4.21
            old:
         php5-cli:
            ----------
            new:
               5.5.9+dfsg-1ubuntu4.21
            old:
         php5-common:
            ----------
            new:
               5.5.9+dfsg-1ubuntu4.21
            old:
         php5-json:
            ----------
            new:
               1.3.2-2build1
            old:
         php5-mhash:
            ----------
            new:
               1
            old:
         php5-mysql:
            ----------
            new:
               5.5.9+dfsg-1ubuntu4.21
            old:
         php5-readline:
            ----------
            new:
               5.5.9+dfsg-1ubuntu4.21
            old:
         phpapi-20121212:
            ----------
            new:
               1
            old:
         ssl-cert:
            ----------
            new:
               1.0.33
            old:
Summary for minion2
------------
Succeeded: 1 (changed = 1)
Failed:    0
------------ 
Total states run:     1
Total run time:  86.738 s

Sekarang, Anda telah menginstal paket di minion2.

Highstate

Sebuah "highstate" adalah cara Salt untuk menentukan Rumus Salt mana yang harus diterapkan ke minion tertentu. Jalankan "highstate" menggunakan perintah berikut.

root@saltmaster:/home/vagrant# salt <targets> state.highstate

top.sls

Saat minion meminta untuk mengeksekusi status tinggi, seperti yang disebutkan sebelumnya, minion meminta top.sls dari master Salt dan mencari rumus yang cocok. Secara default, file ini terletak di /srv/salt/top.sls. Mari kita tambahkan rumus kita ke file top.sls dan tetapkan minion2 sebagai target.

base:
   '*':
      - common
   'minion2’:
      - websetup

Sekarang, jalankan highstate menargetkan minion2 seperti yang ditunjukkan di bawah ini.

root@saltmaster:/home/vagrant# salt 'minion2' state.highstate

Setelah menerapkan ini, Anda bisa melihat yang berikut ini output -

minion2:
----------
   ID: common_packages
   Function: pkg.installed
   Result: True
   Comment: All specified packages are already installed
   Started: 01:55:17.998824
   Duration: 461.615 ms
   Changes:

Summary for minion2
------------
Succeeded: 1
Failed:    0
------------
Total states run:     1
Total run time: 461.615 ms

Sekarang, server web Apache dan PHP diinstal di minion2. Dengan cara ini, kami harus menargetkan minion menggunakan keduanyatop.sls dan highstate dan instal perangkat lunak yang diperlukan dengan pekerjaan minimal dan fleksibilitas maksimum.