KUBERNETES-add aplikasi ke pod

https://www.getambassador.io/blog/deploy-first-application-kubernetes-step-by-step-tutorial 

Dalam tutorial ini, kami akan membahas seluk-beluk Pengembangan Kubernetes dan memandu Anda melalui setiap langkah peluncuran aplikasi pertama Anda! Baik Anda pengembang berpengalaman atau pemula, Kubernetes adalah alat yang potensial untuk mengelola beban kerja dan layanan kontainer.

Apa itu Kubernetes?

Kubernetes adalah platform orkestrasi yang mengotomatiskan penyebaran, penskalaan, dan pengelolaan aplikasi yang dikontainerisasi. Platform ini membantu pengembang untuk berkonsentrasi pada inovasi dan menciptakan produk yang bernilai.

Memaksimalkan Efisiensi dengan Penerapan Kubernetes untuk Aplikasi

Anda mungkin bertanya-tanya, "Mengapa saya harus repot-repot menerapkan aplikasi saya di Kubernetes ?" Misalnya, Anda membangun aplikasi yang luar biasa, dan aplikasi tersebut mendapatkan resistensi lebih cepat daripada Anda dapat mengatakan "Stabilitas."

Tiba-tiba, ketika server Anda mogok karena permintaan yang masuk. Dengan Kubernetes, Anda dapat dengan mudah menskalakan aplikasi Anda untuk menangani peningkatan beban tanpa bersusah payah.

Kubernetes Deployment memberdayakan pengembang untuk menyederhanakan proses deployment, sehingga mereka dapat fokus pada inovasi dan pembuatan produk. Jika salah satu aplikasi Anda mati, Kubernetes akan secara otomatis menjalankan aplikasi yang baru. Hal ini memfasilitasi komunikasi antara tim pengembangan dan operasi serta membantu dalam mengelola infrastruktur aplikasi dengan lebih baik.

Tidak hanya itu, Kubernetes bahkan membantu mengurangi biaya pengelolaan dan pemeliharaan penerapan dengan memungkinkan Anda berfokus pada hal yang benar-benar penting dan membangun perangkat lunak yang mengagumkan.

Dalam tutorial ini akan ditunjukkan proses penerapan aplikasi pertama Anda di Kubernetes langkah demi langkah. Kita akan mulai dengan menyiapkan lingkungan Kubernetes Anda dan memandu Anda melalui Langkah-Langkah Instalasi dan Konfigurasi. Jangan khawatir jika Anda baru mengenal Kubernetes; kita akan melakukannya secara perlahan dan bertahap. Ikuti langkah-langkah berikut untuk penerapan!

Prasyarat untuk Penerapan Kubernetes

LANGKAH 1: Instalasi Kubernetes pada node master dan node kerja:

-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- Baik Node Master maupun Node Pekerja -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --      
sudo su
pembaruan yang tepat - y
apt instal docker .io - y 

systemctl mulai docker
systemctl mengaktifkan docker

curl - fsSL " https://packages.cloud.google.com/apt/doc/apt-key.gpg " | sudo gpg -- dearmor - o /etc/apt/trusted.gpg.d/kubernetes - arsip - gantungan kunci.gpg​​​​​​​​​ 
echo ' deb https://packages.cloud.google.com/apt kubernetes - xenial main ' > /etc/apt/sources.list.d/kubernetes.list​​​​​​  

pembaruan yang tepat - y
apt - install kubeadm = 1.20.0 - 00 kubectl = 1.20.0 - 00 kubelet = 1.20.0 - 00 - y 

# Untuk terhubung dengan cluster, jalankan perintah di atas pada master node dan worker node masing-masing
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- Simpul Induk -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --    
sudo su
kubeadm inisiasi

# Untuk mulai menggunakan klaster Anda , Anda perlu menjalankan yang berikut ini sebagai pengguna biasa :
  mkdir - p $ BERANDA / .kube
sudo   cp - i /etc/kubernetes/admin.conf $ HOME / .kube / config​​​​​​​
sudo   chown $ ( id - u ) : $ ( id - g ) $ BERANDA / .kube / konfigurasi

# Atau , jika Anda adalah pengguna root , Anda dapat menjalankan : 
  ekspor KUBECONFIG = /etc/kubernetes/admin.conf​​​​​​​ 
  
kubectl apply - f https://github.com/weaveworks/weave/releases/download/v2.8.1/weave-daemonset-k8s.yaml​​​​​​​​​​​​​​​​​​​​​​​​

kubeadm token buat -- cetak - gabung - perintah
  

-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- Node Pekerja -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --​​    
sudo su
kubeadm reset pra - pemeriksaan penerbangan
-- -- - > Tempel perintah Gabung pada simpul pekerja dan tambahkan ` --v=5 ` di akhir 

# Untuk memverifikasi koneksi cluster  
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- di Node Utama -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --​​ 

kubectl dapatkan node


# pekerja
# kubeadm join 172.31 .84 .66 : 6443 -- token n4tfb4 . grmew1s1unug0get -- penemuan - token - ca - cert - hash sha256 : c3fda2eaf5960bed4320d8175dc6a73b1556795b1b7f5aadc07642ed85c51069 -- v = 5      
# kubeadm mengatur ulang pemeriksaan pra - penerbangan
# kubeadm token buat -- cetak - gabung - perintah
# kubectl label node ip - 172 - 31 - 20 - 246 node - peran .kubernetes .io / pekerja = pekerja
# kubectl label nodes ip - 172 - 31 - 92 - 99 kubernetes .io / role = pekerja
# konfigurasi kubectl set - konteks $ ( konfigurasi kubectl current - konteks ) -- namespace = dev 

LANGKAH 2: Kloning repositori

Mari kita lihat file Docker di repositori ini

DARI python : 3 

WORKDIR / data 

JALANKAN pip install django == 3.2

SALIN . .  

JALANKAN python kelola .py migrasi

EKSPOS 8000 

CMD [ "python" , "manage.py" , "runserver" , "0.0.0.0:8000" ] 

Ini adalah aplikasi Django yang berjalan pada nomor port

8000

dan titik masuk ke aplikasi adalah

manage.py

Apa itu Kontainer?

Kontainer adalah jenis lingkungan runtime tempat kode aplikasi Anda dikemas dan dijalankan beserta dependensinya. Kluster kontainer adalah sistem dinamis yang mengatur dan mengendalikan kontainer yang beroperasi pada node dalam pod , beserta semua koneksi dan saluran komunikasinya. Ia juga dikelola oleh Kubernetes Deployment dan menawarkan lingkungan runtime yang ringan dan efisien untuk menjalankan aplikasi Anda.

LANGKAH 3: Membangun gambar dari Dockfile

docker build . -t trajendra/django-todo:latest

Buka repositori cd django-todo dan jalankan perintah di atas untuk membuat gambar.

Jalankan perintah docker images untuk mendapatkan daftar gambar.

Gambar berhasil dibuat.

LANGKAH 4: Dorong gambar Docker ke Registri

Masuk ke hub Docker

docker login

Perintah tersebut akan meminta nama pengguna dan kata sandi setelah dijalankan. Setelah memasukkan informasi tersebut, login Anda berhasil.

Dorong gambar untuk mendaftar

docker push trajendra/django-todo:latest

Periksa untuk melihat apakah citra docker telah berhasil dikirim ke registri.

Wah! Anda telah berhasil memasukkan gambar ke registri dan membuatnya. Dari gambar ini, kita akan membuat kontainer.

Ada dua cara utama untuk membuat dan mengelola sumber daya:

1. Antarmuka Baris Perintah

2. Manifes YAML

1. Antarmuka Baris Perintah:

Kubernetes menyediakan alat baris perintah untuk berinteraksi dengan bidang kontrol kluster Kubernetes melalui API Kubernetes.

CLI Kubernetes yang disebut kubectl adalah alat yang memungkinkan Anda berinteraksi dengan Kubernetes Cluster. Alat ini menawarkan serangkaian perintah untuk mengelola, membuat, dan menyesuaikan sumber daya Kubernetes.

2. Manifestasi Yaml

File konfigurasi yang ditulis dalam YAML disebut manifest YAML. Status ideal Pod, Deployment, ConfigMaps , Secret, dan banyak hal lainnya ditetapkan dalam file ini.

Mari kita mulai dengan apa itu POD.

Unit terkecil dari aplikasi Kubernetes disebut pod, yang merupakan pengelompokan dari satu atau beberapa kontainer Linux®. Satu atau beberapa kontainer yang saling terkait erat (kasus penggunaan tingkat lanjut) atau hanya satu kontainer (kasus penggunaan yang lebih umum) dapat membentuk pod tertentu. Kubernetes Deployment mengatur penyebaran pod, memastikan bahwa komponen aplikasi Anda didistribusikan dan dikelola secara efisien.

Untuk menyebarkan aplikasi kita, kita akan menggunakan YAML Manifest.

TUGAS 1: buat Pod pertama Anda

Manifest YAML akan digunakan untuk membuat satu pod.

Versi api : v1
jenis : Pod 
metadatanya :
  nama : django - aplikasi
spesifikasi :
  wadah :
  - nama : django - aplikasi
    gambar : trajendra / django - todo : terbaru
    pelabuhan : 
    - kontainerPort : 8000 

• apiVersion: v1
  menentukan versi API Kubernetes yang digunakan.
• kind: Pod
  menunjukkan bahwa Anda sedang membuat objek Pod.
• metadata
  berisi metadata tentang Pod, termasuk namanya.
• spec
  mendefinisikan status Pod yang diinginkan.
• containers
  serangkaian objek kontainer yang berjalan di dalam Pod. Dalam kasus ini, hanya ada satu kontainer.
• name: crud-backend-app
  menetapkan nama kontainer menjadi "crud-backend-app".
• image: trajendra/crudbackend:latest
  menentukan citra Docker yang akan digunakan untuk kontainer. Dalam kasus ini, citra "trajendra/django-todo" dengan tag "latest" digunakan.
• ports
  mendefinisikan port jaringan yang diekspos kontainer. Dalam contoh ini, port 8000 diekspos.


kubectl apply -f pod.yml

Dengan menggunakan perintah ini, Kubernetes akan membaca berkas YAML kita dan membuat pembaruan yang diperlukan pada semua sumber daya kluster.

• Hubungkan ke Node Pekerja untuk memverifikasi apakah kontainer berhasil dibuat.

docker ps

• Sekarang mari masuk ke wadah dan jalankan perintah curl.

docker exec -it 3551dae bash

Halo! Dengan YAML Manifests, kami berhasil membuat kontainer melalui pod.

RUANG NAMA

Saat membuat namespace, pertimbangkan struktur organisasi penerapan Anda, untuk memastikan bahwa Penerapan Kubernetes dapat mengelola sumber daya secara efisien di berbagai lingkungan. Dalam sebuah kluster, pengelompokan logis yang disebut namespace dibentuk. Pengelompokan ini memungkinkan koeksistensi beberapa tim atau aplikasi dalam satu kluster.

• Secara default, Kubernetes menyediakan namespace default tempat sumber daya dibuat jika tidak ada namespace tertentu yang ditentukan
• Anda dapat menentukan kebijakan RBAC (Kontrol Akses Berbasis Peran) untuk memberikan berbagai tingkat akses ke sumber daya berdasarkan namespace.

LANGKAH 5: buat namespace

kubectl create namespace my-django-app

Kita akan membuat namespace bagi aplikasi kita untuk menyertakan semua pod, layanan, deployment, dan container dalam namespace ini.

TUGAS 2: Membuat pod di dalam Namespace

Versi api : v1
jenis : Pod 
metadatanya :
  nama : django - aplikasi
  namespace : aplikasi - django - saya
spesifikasi :
  wadah :
  - nama : django - aplikasi
    gambar : trajendra / django - todo : terbaru
    pelabuhan : 
    - kontainerPort : 8000 

• Untuk membuat pod, jalankan perintah berikut:

kubectl apply -f pod.yml

• Untuk memverifikasi pod yang dibuat di dalam namespace

kubectl get pods -n=my-django-app

Menghapus POD

kubectl delete -f pod.yml

Di sini, pod akan dihapus dari namespace

Kami telah menambahkan namespace dan metadata.

Penempatan

• Penerapan Kubernetes yang dikonfigurasikan dengan baik memastikan kelancaran operasi aplikasi Anda, mengelola pembaruan, dan meningkatkan skala dengan mulus.
• Kubernetes melacak kesehatan Pod dalam manajemen penerapan. Untuk mempertahankan jumlah replika yang dibutuhkan, Kubernetes secara otomatis mengganti Pod yang tidak berfungsi atau berhenti merespons.

LANGKAH 6: Buat Deployment

Versi api : aplikasi / v1
jenis : Penyebaran 
metadatanya :
  nama : my - django - app - deployment
  label :
    aplikasi : django - aplikasi
  namespace : aplikasi - django - saya
spesifikasi :
  replika : 3 
  pemilih :
    LabelPertandingan :
      aplikasi : django - aplikasi
  templat :
    metadatanya :
      label :
        aplikasi : django - aplikasi
    spesifikasi :
      wadah :
      - nama : django - aplikasi - wadah
        gambar : trajendra / django - todo : terbaru
        pelabuhan :
        - kontainerPort : 8000 

Dalam Manifest di atas, kami telah mendeklarasikan penerapan dan hal-hal yang perlu kami ketahui.

kind:

Menentukan jenis sumber daya, yang dalam kasus ini adalah Penyebaran.

selector:

Menentukan label yang digunakan untuk memilih Pod mana yang menjadi bagian dari Penyebaran ini.

• matchLabels:
  Menentukan label yang harus dimiliki Pod agar dianggap sebagai bagian dari Deployment. Dalam kasus ini, Pod dengan label
• replicas:
  Menentukan jumlah replika (Pod) yang diinginkan untuk dipertahankan, ditetapkan ke 3 dalam contoh ini.
• template:
  Menentukan templat Pod yang digunakan untuk membuat Pod yang dikelola oleh Deployment.
• spec:
  Menentukan spesifikasi untuk Pod yang dibuat dari templat.

kubectl apply -f deployment.yml # run the deployment
kubectl get pods -n=my-django-app # get the list of pods in namespace

Anda kemudian dapat menggunakan perintah tersebut untuk membuat atau memperbarui Deployment di klaster Kubernetes Anda.

Untuk mendapatkan pod yang dibuat di dalam namespace

kubectl get pods -n=my-django-app.

Skala

Digunakan untuk menskalakan jumlah replika (pod) dalam Penyebaran.

TUGAS 3: Membuat 10 replika menggunakan perintah Kubernetes CLI


kubectl scale deployment my-django-app-deployment --replicas=10 -n=my-django-app

--replicas=10

: Mengatur jumlah replika (Pod) yang diinginkan menjadi 10. Ini berarti Kubernetes akan menyesuaikan jumlah Pod dalam Deployment agar sesuai dengan nilai ini.

Ini telah membuat 10 pod dalam kelompok

Melayani

Anda mengoperasikan aplikasi web dalam penerapan yang memiliki beberapa pod. Setiap pod memiliki alamat IP unik yang dapat berubah secara dinamis. Saat jumlah pod bertambah atau berkurang, metode ini menjadi tidak layak. Anda dapat mengembangkan layanan untuk mengatasi masalah ini.

LANGKAH 7: PAPARKAN Aplikasi Anda ke pengguna eksternal

NodePort: Membuka port pada setiap alamat IP node kluster untuk Layanan. mengizinkan pengguna eksternal untuk mengakses layanan. Kami menggunakan rentang IP NodePort yang diizinkan (30007–32767).

port:

Menentukan nomor port pada Layanan itu sendiri. Dalam hal ini, nomor port tersebut ditetapkan

targetPort

: Menentukan nomor port pada Pod yang akan menjadi tujuan penerusan lalu lintas Layanan. Dalam contoh ini

nodePort: 30009

itu sudah diatur untuk

30009

, yang berarti lalu lintas yang tiba di

nodeIP:30009

akan diarahkan ke Layanan.

kubectl apply -f service.yml

Edit aturan masuk dalam grup keamanan instans EC2 dan klik simpan aturan.

Selamat! Kami telah berhasil menerapkan aplikasi todo pada Kubernetes Cluster.

Menguasai Penerapan Kubernetes

Selamat karena telah menyelesaikan tutorial tentang penerapan aplikasi pertama Anda di Kubernetes! Kami senang menjadi bagian dari perjalanan Anda untuk menjadi ahli penerapan Kubernetes.

Sebagai kesimpulan, Kubernetes menyediakan serangkaian alat dan strategi yang canggih untuk mengendalikan penerapan, mengurangi biaya, dan meningkatkan keandalan. Dengan memanfaatkan fitur-fitur seperti kemampuan rollback, Pod, Penerapan, dan strategi penerapan tingkat lanjut, kami dapat mengurangi waktu henti dan pada akhirnya menghemat biaya infrastruktur dan operasional.

Beralih ke aspek praktis penerapan aplikasi di Kubernetes. Dengan menguasai teknik Penerapan Kubernetes, Anda akan membuka potensi penuh, mencapai efisiensi dan Skalabilitas yang tak tertandingi dalam penerapan aplikasi Anda.