Kubernetes tampaknya adalah tentang menerapkan container ke cloud cluster. Apa yang tampaknya tidak disentuh adalah lingkungan pengembangan dan pementasan (atau semacamnya).

Selama pengembangan, Anda ingin sedekat mungkin dengan lingkungan produksi dengan beberapa perubahan penting:

• Diterapkan secara lokal (atau setidaknya di suatu tempat di mana Anda dan hanya Anda yang dapat mengakses )
• Gunakan kode sumber terbaru pada penyegaran halaman (misalkan itu adalah situs web; idealnya penyegaran otomatis halaman pada penyimpanan file lokal yang dapat dilakukan jika Anda memasang kode sumber dan menggunakan beberapa hal seperti Yeoman ).

Demikian pula seseorang mungkin menginginkan lingkungan non-publik melakukan integrasi berkelanjutan .

Apakah Kubernetes mendukung lingkungan pengembangan semacam itu atau apakah itu sesuatu yang harus dibangun, dengan harapan selama produksi itu akan tetap berfungsi?

Perbarui (2016-07-15)

Dengan dirilisnya Kubernetes 1.3, Minikube sekarang menjadi cara yang direkomendasikan untuk menjalankan Kubernetes di komputer lokal Anda untuk pengembangan.

Anda dapat menjalankan Kubernetes secara lokal melalui Docker . Setelah Anda menjalankan node, Anda dapat meluncurkan pod yang memiliki server web sederhana dan memasang volume dari mesin host Anda. Ketika Anda menekan server web, itu akan membaca dari volume dan jika Anda telah mengubah file di disk lokal Anda, itu dapat melayani versi terbaru.

Kami sedang mengerjakan alat untuk melakukan ini. Ide dasarnya adalah Anda memiliki cluster Kubernetes jarak jauh, yang secara efektif merupakan lingkungan pementasan, dan kemudian Anda menjalankan kode secara lokal dan itu akan di-proxy-kan ke cluster jarak jauh. Anda mendapatkan akses jaringan transparan, variabel lingkungan disalin, akses ke volume ... sedekat mungkin dengan lingkungan jarak jauh, tetapi dengan kode Anda berjalan secara lokal dan di bawah kendali penuh Anda.

Jadi Anda bisa melakukan pengembangan langsung, katakanlah. Docs di http://telepresence.io

Semacam "hot reload" adalah sesuatu yang kami rencanakan untuk ditambahkan, tetapi tidak semudah seperti sekarang. Namun, jika Anda ingin berpetualang, Anda dapat menggunakan rsync dengan docker exec, kubectl exec, atau osc exec (semuanya melakukan hal yang sama secara kasar) untuk menyinkronkan direktori lokal ke dalam container setiap kali ada perubahan. Anda dapat menggunakan rsync dengan kubectl atau osc exec seperti ini:

# rsync using osc as netcat
$ rsync -av -e 'osc exec -ip test -- /bin/bash' mylocalfolder/ /tmp/remote/folder

Titik awal bagus lainnya adalah pengaturan Vagrant ini , khususnya. jika OS host Anda adalah Windows. Keuntungan yang jelas

• pengaturan cepat dan tidak menyakitkan
• mudah untuk menghancurkan / membuat ulang mesin
• batas implisit pada sumber daya
• kemampuan untuk menguji penskalaan horizontal dengan membuat beberapa node

Kerugiannya - Anda membutuhkan banyak RAM, dan VirtualBox adalah VirtualBox ... baik atau buruk.

Keuntungan / kerugian campuran adalah memetakan file melalui NFS. Dalam pengaturan kami, kami membuat dua set definisi RC - satu yang hanya mendownload gambar buruh pelabuhan dari server aplikasi kami; yang lainnya dengan 7 baris tambahan yang mengatur pemetaan file dari HostOS -> Vagrant -> VirtualBox -> CoreOS -> Kubernetes pod; menimpa kode sumber dari image Docker.

Kelemahan dari ini adalah cache file NFS - dengan itu, itu bermasalah, tanpanya, itu sangat lambat. Bahkan pengaturan mount_options: 'nolock,vers=3,udp,noac'tidak menghilangkan masalah caching sepenuhnya, tetapi itu berfungsi sebagian besar waktu. Beberapa tugas Gulp yang dijalankan dalam wadah dapat memerlukan waktu 5 menit jika memerlukan waktu 8 detik pada OS host. Kompromi yang bagus sepertinya mount_options: 'nolock,vers=3,udp,ac,hard,noatime,nodiratime,acregmin=2,acdirmin=5,acregmax=15,acdirmax=15'.

Sedangkan untuk pemuatan ulang kode otomatis, itu khusus bahasa, tetapi kami senang dengan devserver Django untuk Python, dan Nodemon untuk Node.js. Untuk proyek frontend, tentu saja Anda dapat melakukan banyak hal dengan sesuatu seperti gulp + browserSync + watch, tetapi bagi banyak pengembang, tidak sulit untuk melayani dari Apache dan hanya melakukan hard refresh tradisional.

Kami menyimpan 4 set file yaml untuk Kubernetes. Dev, "devstable", stage, prod. Perbedaan di antara keduanya adalah

• Variabel env secara eksplisit mengatur lingkungan (dev / stage / prod)
• jumlah replika
• devstable, stage, prod menggunakan gambar buruh pelabuhan
• dev menggunakan gambar buruh pelabuhan, dan memetakan folder NFS dengan kode sumber di atasnya.

Sangat berguna untuk membuat banyak alias bash dan pelengkapan otomatis - Saya cukup mengetik rec usersdan itu akan dilakukan kubectl delete -f ... ; kubectl create -f .... Jika saya ingin seluruh pengaturan dimulai, saya mengetik recfo, dan itu membuat ulang selusin layanan, menarik gambar buruh pelabuhan terbaru, mengimpor db dump terbaru dari Staging env dan membersihkan file Docker lama untuk menghemat ruang.

Saya baru saja mulai dengan Skaffold

Sangat berguna untuk menerapkan perubahan dalam kode secara otomatis ke cluster lokal.

Untuk menerapkan cluster lokal, cara terbaik adalah Minikube atau hanya Docker untuk Mac dan Windows, keduanya menyertakan antarmuka Kubernetes.

Lihat https://github.com/kubernetes/kubernetes/issues/12278 untuk cara memasang volume dari mesin host, yang setara dengan:

docker run -v hostPath:ContainerPath

Memiliki umpan balik pengembangan lokal yang bagus adalah topik perkembangan pesat di ekosistem Kubernetes.

Menguraikan pertanyaan ini, ada beberapa alat yang saya yakin mendukung tujuan ini dengan baik.

Docker untuk Mac Kubernetes

Docker untuk Mac Kubernetes ( Desktop Docker adalah nama lintas platform generik) menyediakan opsi yang sangat baik untuk pengembangan lokal. Untuk virtualisasi, ini menggunakan HyperKit yang dibangun di atas kerangka kerja Hypervisor asli di macOS, bukan VirtualBox.

Fitur Kubernetes pertama kali dirilis sebagai beta di edge channel di Januari 2018 dan telah berkembang pesat sejak itu, menjadi Kubernetes bersertifikat pada April 2018 , dan lulus ke saluran stabil pada Juli 2018 .

Menurut pengalaman saya, ini jauh lebih mudah untuk digunakan daripada Minikube, terutama di macOS, dan terutama jika menyangkut masalah seperti RBAC, Helm, hypervisor, registri pribadi, dll.

Kemudi

Sejauh mendistribusikan kode Anda dan menarik pembaruan secara lokal, Helm adalah salah satu opsi paling populer. Anda dapat memublikasikan aplikasi Anda melalui CI / CD sebagai bagan Helm (dan juga gambar Docker yang mendasari yang dirujuknya). Kemudian Anda dapat menarik bagan ini dari registri bagan Helm secara lokal dan meningkatkannya di kluster lokal Anda.

Draf Azure

Anda juga dapat menggunakan alat seperti Azure Draft untuk melakukan penerapan lokal sederhana dan membuat bagan Helm dasar dari templat bahasa umum, seperti paket build, untuk mengotomatiskan potongan teka-teki itu.

Skaffold

Skaffold seperti Azure Draft tetapi lebih matang, cakupannya lebih luas, dan dibuat oleh Google. Ini memiliki arsitektur yang sangat mudah dipasang. Saya rasa di masa mendatang akan lebih banyak orang yang akan menggunakannya untuk pengembangan aplikasi lokal Kubernetes.

Jika Anda pernah menggunakan React, saya menganggap Skaffold sebagai " Buat Aplikasi React untuk Kubernetes".

Menulis atau Menulis di Kubernetes

Docker Compose , meskipun tidak terkait dengan Kubernetes, adalah salah satu alternatif yang digunakan beberapa perusahaan untuk menyediakan lingkungan pengembangan lokal yang sederhana, mudah, dan portabel yang serupa dengan lingkungan Kubernetes yang mereka jalankan dalam produksi. Namun, mengikuti rute ini berarti mengalihkan produksi dan pengaturan pengembangan lokal Anda.

Kompose adalah konverter Docker Compose ke Kubernetes. Ini bisa menjadi jalur yang berguna bagi seseorang yang sudah menjalankan aplikasinya sebagai kumpulan penampung secara lokal.

Compose on Kubernetes adalah penawaran open source (Desember 2018) dari Docker yang memungkinkan penerapan file Docker Compose langsung ke cluster Kubernetes melalui pengontrol kustom.

Kubespary sangat membantu dalam menyiapkan cluster lokal. Sebagian besar, saya menggunakan cluster berbasis gelandangan di mesin lokal.

Konfigurasi Kubespray Anda dapat mengubah variabel-variabel ini agar memiliki versi kubernetes yang diinginkan.

Kerugian penggunaan minkubeadalah memunculkan mesin virtual lain di atas mesin Anda. Selain itu, dengan minikubeversi terbaru , minimal memerlukan 2 CPU dan 2GB RAM dari sistem Anda, yang membuatnya cukup berat jika Anda tidak memiliki sistem dengan sumber daya yang cukup.

Inilah alasan saya beralih ke microk8spengembangan di kubernetes dan saya menyukainya. microk8smendukung DNS, penyimpanan lokal, dasbor, istio, ingress, dan banyak lagi, semua yang Anda butuhkan untuk menguji layanan mikro Anda.

Ini dirancang untuk menjadi instalasi Kubernetes upstream yang cepat dan ringan yang terisolasi dari lingkungan lokal Anda. Isolasi ini dicapai dengan mengemas semua binari untuk Kubernetes, Docker.io, iptables, dan CNI dalam satu paket snap.

Cluster kubernetes node tunggal dapat diinstal dalam satu menit dengan satu perintah:

snap install microk8s --classic

Pastikan sistem Anda tidak menjalankan layanan galangan atau kubelet. Microk8sakan menginstal semua layanan yang diperlukan secara otomatis.

Silakan lihat tautan berikut untuk mengaktifkan pengaya lain di microk8s.

https://github.com/ubuntu/microk8s

Anda dapat memeriksa status menggunakan:

velotio@velotio-ThinkPad-E470:~/PycharmProjects/k8sClient$ microk8s.status
microk8s is running
addons:
ingress: disabled
dns: disabled
metrics-server: disabled
istio: disabled
gpu: disabled
storage: disabled
dashboard: disabled
registry: disabled

Silahkan lihat pada https://github.com/okteto/okteto dan Okteto Cloud . Proposisi nilainya adalah memiliki pengalaman pengembangan klasik daripada bekerja secara lokal, sebelum buruh pelabuhan, di mana Anda dapat memiliki hot-reload, incremental build, debugger ... tetapi semua perubahan lokal Anda segera disinkronkan ke container jarak jauh. Kontainer jarak jauh memberi Anda akses ke kecepatan cloud, memungkinkan tingkat kolaborasi baru, dan mengintegrasikan pengembangan dalam lingkungan seperti produksi. Juga, menghilangkan beban instalasi lokal.

Seperti yang ditentukan sebelumnya oleh Robert, minikube adalah cara terbaik.

Berikut adalah panduan cepat untuk memulai dengan minikube. Langkah-langkah umumnya adalah:

• Instal minikube

• Buat cluster minikube (dalam Mesin Virtual yang dapat berupa VirtualBox atau Docker untuk Mac atau HyperV dalam kasus Windows)

• Buat image Docker dari file aplikasi Anda (dengan menggunakan Dockerfile)

• Jalankan gambar dengan membuat Deployment

• Buat layanan yang mengekspos aplikasi Anda sehingga Anda dapat mengaksesnya.

Berikut adalah cara saya melakukan pengaturan lokal untuk Kubernetes di Windows 10: -

• Gunakan Docker Desktop

• Aktifkan Kubernetes di opsi pengaturan Docker Desktop

• Di Docker Desktop secara default resource yang dialokasikan untuk Memory adalah 2GB sehingga untuk menggunakan Kubernetes dengan Docker Desktop menambah memorinya.

• Instal kubectl sebagai klien untuk berbicara dengan cluster Kubernetes

• Jalankan perintah kubectl config get-contexts untuk mendapatkan cluster yang tersedia

• Jalankan perintah kubectl config use-context docker-desktop untuk menggunakan desktop buruh pelabuhan

• Buat gambar buruh pelabuhan dari aplikasi Anda

• Tulis file YAML (metode deskriptif untuk membuat penerapan Anda di Kubernetes) yang mengarah ke gambar yang dibuat di cluster langkah di atas

• Ekspos layanan jenis port node untuk setiap penerapan Anda agar tersedia untuk dunia luar