Lasso adalah kerangka pengontrol.
Lasso memiliki beberapa kesamaan fungsional dengan proyek runtime pengontrol dan dapat digunakan sebagai pengganti runtime pengontrol.
Lasso levelnya rendah. Jika Anda ingin mengelola pengontrol Anda sendiri maka Anda dapat menggunakannya. Jika Anda mencari kenyamanan dan fungsionalitas lebih untuk membuat jenis sumber daya Anda sendiri, kami sarankan untuk memeriksa Wrangler.
Kerangka pengontrol inti yang digunakan oleh Wrangler dan Norman.
Dokumen ini ditulis dengan mempertimbangkan dua audiens: seseorang yang baru mengenal pengontrol Kubernetes dan seseorang yang bukan orang baru dalam pengontrol Kubernetes tetapi baru mengenal laso.
Jika Anda termasuk dalam kategori "Seseorang yang bukan orang baru dalam pengontrol Kubernetes", Anda dapat melompat ke Proposisi Nilai Lasso.
Jika Anda baru mengenal pengontrol Kubernetes, disarankan agar Anda tidak melewatkan bagian mana pun.
Jika Anda kurang memiliki pengetahuan dasar tentang Kubernetes, disarankan agar Anda membaca dokumentasi dasar lainnya terlebih dahulu, seperti Ikhtisar Kubernetes.
Catatan: Ini akan menjadi kursus kilat yang sangat singkat. Kami mendorong Anda untuk mencari sumber lain mengenai topik ini, ada banyak! Dua sumber daya yang direkomendasikan adalah Sample Controller Project dan Pengantar Kerangka Pengontrol Kubernetes.
Dari Dokumentasi Kubernetes
Di Kubernetes, pengontrol adalah loop kontrol yang memantau status bersama cluster melalui apiserver dan membuat perubahan untuk mencoba memindahkan status saat ini ke status yang diinginkan.
Kata "pengontrol" digunakan lebih longgar daripada definisi di atas yang mungkin Anda yakini. Dengan kata lain: Pengontrol adalah pengendali loop yang bertindak sebagai respons terhadap peristiwa sumber daya Kubernetes. Di Lasso, kami juga menggunakan kata "pengontrol" untuk merujuk pada seluruh struktur yang bertanggung jawab untuk mendaftarkan pengendali loop ini dan menyediakan sumber daya yang dibutuhkannya. Singkatnya, pengontrol adalah struktur yang menggabungkan semua yang diperlukan untuk berinteraksi dan beroperasi pada tipe Kubernetes.
Untuk mencapai tujuan di atas, ada beberapa sub-tujuan yang perlu dipenuhi:
Ada banyak kerangka kerja untuk membantu mencapai tujuan di atas. Lasso adalah salah satunya. Kesamaan dari sebagian besar kerangka kerja ini, termasuk laso, adalah bahwa mereka menggunakan fungsionalitas dari client-go untuk mencapai tujuan ini. Anda dapat mencapai tujuan ini hanya dengan menggunakan client-go. Untuk sisa bagian ini, kita akan membahas bagaimana pengontrol disatukan hanya menggunakan konsep client-go.
Seorang informan digunakan untuk mencapai tujuan di atas yang diperlukan untuk Pengendali Kubernetes. Seorang informan memiliki event handler dan pengindeks. Pengindeks memiliki fungsi penyimpanan dan peta untuk mengindeks objek di dalam penyimpanan yang disebut pengindeks. Struktur dasarnya berbeda, tetapi struktur semu ditampilkan di bawah untuk mengilustrasikannya:
Informer
EventHandler
Indexer
Store
Indexers
EventHandler dapat memiliki logika berbeda untuk membuat, memperbarui, dan menghapus peristiwa. Pengendali peristiwa adalah tempat pengontrol masuk. Anda menggunakannya untuk mengonfigurasi pengendali peristiwa membuat, memperbarui, dan menghapus.
Pengindeks digunakan sebagai cache.
Penyimpanan adalah tempat pengindeks menyimpan objek.
Pengindeks adalah fungsi yang dapat digunakan pengindeks untuk mengindeks objek yang disimpan. Setelah diindeks dengan pengindeks, objek dapat diambil menggunakan string yang menggambarkan karakteristik yang menjadi perhatian pengindeks.
Pengindeks akan sering digunakan untuk mengambil objek dengan metadata sederhana seperti namespace dan nama.
Informan pertama-tama mengisi pengindeks dengan mencantumkan semua sumber daya yang dikembalikan dari klien. Kemudian informan mengamati sumber daya Kubernetes yang ditugaskan padanya. Ketika suatu peristiwa muncul, ia menggunakan peristiwa itu untuk memperbarui pengindeksnya dan mengeksekusi pengendali peristiwanya.
Biasanya suatu aplikasi menginginkan banyak pengontrol. Namun, mungkin tidak efisien jika setiap pengontrol memiliki informan dan pengindeksnya sendiri. SharedIndexerInformer dari client-go dapat digunakan untuk menambahkan beberapa pengontrol yang semuanya menggunakan pengindeks yang sama.
Ada gambaran bagus tentang cara kerja pengontrol Kubernetes yang dapat ditemukan di repo kubernetes/sample-controller.
Catatan: Informan telah disederhanakan demi singkatnya. Jika Anda tertarik dengan cara kerjanya, Anda disarankan untuk membaca kode client-go.
Lasso membakukan apa itu pengontrol dengan paket pengontrolnya. Lasso memperkenalkan pabrik untuk mengelola cache, pengontrol, dan klien dalam suatu proyek. Hal ini penting bagi peternak yang mengelola banyak contoh dari berbagai jenis.
Pengontrol laso menggunakan antrian kerja client-go. Lasso mendaftarkan event handler yang memproses antrian pekerjaan. Pengendali yang berorientasi antrian kerja membuat hanya satu pengendali kejadian yang perlu ditambahkan untuk setiap jenis Kubernetes. Sekarang mendaftarkan penangan hanya menambahkannya ke daftar penangan pengontrol tipe. Mengantri suatu objek akan menambahkannya ke antrian pekerjaan. Setiap objek dalam antrian pekerjaan kemudian akan diproses oleh pekerja yang berjalan di goroutine. Pengendali kejadian pengontrol akan mengantrekan ulang objek apa pun yang menyebabkan satu atau lebih pengendali pengontrol mengembalikan kesalahan yang bukan bertipe ErrIgnore . Antrian kerja ini juga dapat memiliki objek yang diantrekan dari sumber lain. Fungsionalitas ini diekspos melalui fungsi Enqueue pengontrol. Hal ini mengubah pengontrol dari yang hanya reaktif terhadap sumber daya Kubernetes dan sinkronisasi ulang cache, menjadi juga dapat dipanggil dengan kode.
Tipe sharedController menyematkan antarmuka Pengontrol untuk mengekspos fungsionalitas pengontrolnya. sharedController juga memperlihatkan fungsi RegisterHandler bersama dengan fungsi Klien. RegisterHandler menambahkan handler yang diteruskan ke daftar handler pengontrol dan Klien mengembalikan klien untuk jenis sumber daya yang sesuai dengan sharedController; sharedController memiliki bidang GVK (Jenis Versi Grup) yang menunjukkan untuk jenisnya.
Aspek "Berbagi" dimulai dari Lasso Controller yang lebih primitif. Penggunaan antrian kerja memungkinkan satu set Event Handler untuk dibagikan misalnya. Kemudian Lasso Shared Controller menambahkannya dengan mengadakan klien yang dapat digunakan kembali untuk GVK dan menambahkan cara untuk dengan mudah mendaftarkan penangan ke Controller di bawahnya dengan RegisterHandler.
sharedController dapat membuat pengontrol yang mendasarinya. Ini hanya akan melakukannya setelah handler didaftarkan ke sharedController.
Membungkus klien Kubernetes. Berisi bidang GVK untuk mengelola klien di struktur induk seperti sharedClientFactory. Mengekspos beberapa fungsi tambahan seperti mengonfigurasi header Agen-Pengguna untuk klien REST yang mendasarinya.
Laso Cache adalah pembungkus ringan di sekitar SharedIndexInformer dari client-go.
Manfaat utama Lasso Cache adalah dapat ditetapkan Pabrik Cache, yang mengelola SharedIndexInformer di memori oleh GVK sehingga dapat digunakan kembali. Saat menggunakan fungsi Lasso Cache, ia akan mengatur dirinya sendiri di dalam CacheFactory yang diteruskan untuk membuatnya.
Pabrik cache bersama menyimpan Cache dan memungkinkannya dikelola melalui struct GVK. Setelah Cache dibuat, mereka dapat digunakan kembali.
Pabrik Klien Bersama ada sehingga klien untuk GVK dapat digunakan kembali setelah dibuat.
SharedControllerFactory menyatukan semua hal di atas. Ini memungkinkan satu titik masuk untuk mengakses klien, cache, dan penangan – semuanya dikelola untuk Anda. Hal ini dimungkinkan untuk berinteraksi terutama dengan pabrik pengontrol bersama. Ini akan membuat semua pengontrol, klien, dan cache yang Anda perlukan. Ini akan memastikan tidak ada duplikat dari objek-objek ini. Ini akan mencegah kondisi balapan.
Setelah Anda menggunakan ForObject, ForKind, ForResource, atau ForResourceKind, SharedControllerFactory akan melakukan hal berikut: 
deferredController adalah fungsi yang, setelah dijalankan, akan membuat dan mengembalikan pengontrol. Ini akan membuat pengontrol menggunakan cache dari SharedCacheFactory. Tujuan fungsi deferredController adalah untuk menunda pengisian cache hingga benar-benar diperlukan. Hal ini memastikan hanya sumber daya Kubernetes yang memiliki penangan terdaftar, telah dimasukkan dalam antrean, atau cache pengontrolnya diminta, yang disimpan dalam memori.
Saat Anda mendapatkan sharedController dari SharedControllerFactory, Kontroler yang mendasarinya belum dipakai. Sebaliknya, ia akan memanggil metode deferredController untuk membuatnya setelah salah satu operasi yang disebutkan dilakukan.
Di bawah ini adalah langkah-langkah cara mudah untuk mendaftarkan penangan dan menjalankannya di laso:
package main
import (
"context"
"github.com/rancher/lasso/pkg/controller"
appsv1 "k8s.io/api/apps/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/runtime"
"k8s.io/client-go/rest"
)
func main () {
config , err := clientcmd . BuildConfigFromFlags ( "" , os . Getenv ( "KUBECONFIG" ))
if err != nil {
panic ( err )
}
// Setup types you want to work with
scheme := runtime . NewScheme ()
appsv1 . AddToScheme ( scheme )
controllerFactory , err := controller . NewSharedControllerFactoryFromConfig ( config , scheme )
if err != nil {
panic ( err )
}
// ForObject, ForKind, ForResource, and ForResourceKind can all be used to retrieve the controller.
// They all accept different parameters but the first three all eventually call ForResourceKind.
// Refer to [How to use Lasso](#how-to-use-lasso) for more information on how ForResourceKind works.
sharedController , err := controllerFactory . ForObject ( & appsv1. Deployment {})
if err != nil {
panic ( err )
}
// Register a handler on a shared controller. If you need a dedicated queue then use controller.New()
sharedController . RegisterHandler ( context . TODO (), "my-handler" , controller . SharedControllerHandlerFunc ( func ( key string , obj runtime. Object ) (runtime. Object , error ) {
// obj is the latest version of this obj in the cache and MAY BE NIL when an object is finally deleted
dep , ok := obj .( * appsv1. Deployment )
if ! ok {
return obj , nil
}
// Do some stuff ...
// Get stuff from the cache
sharedController . Informer (). GetStore (). Get ( key )
result := & appsv1. Deployment {}
err := sharedController . Client (). Update ( ctx , dep . Namespace , dep , result , metav1. UpdateOptions {})
// return the latest version of the object
return result , err
}))
// the second, int parameter is the number of workers to be used for EACH controller.
err = controllerFactory . Start ( context . TODO (), 5 )
if err != nil {
panic ( err )
}
}Beberapa tes laso menggunakan envtest untuk dijalankan. Envtest memungkinkan pengujian dijalankan terhadap server kubernetes "palsu" dengan sedikit/tanpa overhead.
Untuk menginstal biner setup-envtest yang diperlukan, gunakan perintah berikut:
go install sigs.k8s.io/controller-runtime/tools/setup-envtest@latestSebelum menjalankan pengujian, Anda harus menjalankan perintah berikut untuk menyiapkan server palsu:
# note that this will use a new/latest version of k8s. Our CI will run against the version of k8s that corresponds to lasso's
# current client-go version, as seen in scripts/test.sh
export KUBEBUILDER_ASSETS= $( setup-envtest use -p path )Sumber daya berikut sangat membantu dalam menulis dokumen ini. Mereka sangat disarankan untuk mempelajari lebih dari apa yang disajikan di sini:
