Apa perbedaan antara jenis layanan ClusterIP, NodePort, dan LoadBalancer di Kubernetes?

1 - Saya membaca dokumentasi dan saya sedikit bingung dengan kata-katanya. Ia mengatakan:

ClusterIP : Mengekspos layanan pada IP cluster-internal. Memilih nilai ini membuat layanan hanya dapat dijangkau dari dalam kluster. Ini adalah ServiceType default

NodePort : Mengekspos layanan pada setiap Node's IP pada port statis (NodePort). Layanan ClusterIP, yang akan dirutekan oleh layanan NodePort, dibuat secara otomatis. Anda dapat menghubungi layanan NodePort, dari luar cluster, dengan meminta <NodeIP>:<NodePort>.

LoadBalancer : Mengekspos layanan secara eksternal menggunakan penyeimbang beban penyedia cloud. Layanan NodePort dan ClusterIP, yang akan dirutekan oleh penyeimbang beban eksternal, dibuat secara otomatis.

Apakah jenis layanan NodePort masih menggunakan ClusterIPtetapi hanya pada port yang berbeda, yang terbuka untuk klien eksternal? Jadi dalam hal ini <NodeIP>:<NodePort>sama dengan <ClusterIP>:<NodePort>?

Atau apakah NodeIPIP yang sebenarnya ditemukan saat Anda menjalankan kubectl get nodesdan bukan IP virtual yang digunakan untuk jenis layanan ClusterIP?

2 - Juga dalam diagram dari tautan di bawah:

http://kubernetes.io/images/docs/services-iptables-overview.svg

Apakah ada alasan khusus mengapa Clientada di dalam Node? Saya berasumsi itu harus berada di Clusterdalam kasus tipe layanan ClusterIP.

Jika diagram yang sama dibuat untuk NodePort, apakah valid untuk menggambar klien sepenuhnya di luar Nodedan Clusteratau apakah saya benar-benar kehilangan intinya?

ClusterIP memperlihatkan hal-hal berikut:

• spec.clusterIp:spec.ports[*].port

Anda hanya dapat mengakses layanan ini saat berada di dalam cluster. Itu dapat diakses dari spec.clusterIpport -nya . Jika a spec.ports[*].targetPortdiatur maka akan merutekan dari port ke targetPort. CLUSTER-IP yang Anda dapatkan saat menelepon kubectl get servicesadalah IP yang ditetapkan untuk layanan ini dalam cluster secara internal.

NodePort memperlihatkan hal-hal berikut:

• <NodeIP>:spec.ports[*].nodePort
• spec.clusterIp:spec.ports[*].port

Jika Anda mengakses layanan ini pada nodePort dari IP eksternal node, itu akan merutekan permintaan ke spec.clusterIp:spec.ports[*].port, yang pada gilirannya akan merutekannya ke Anda spec.ports[*].targetPort, jika diatur. Layanan ini juga dapat diakses dengan cara yang sama seperti ClusterIP.

NodeIP Anda adalah alamat IP eksternal dari node tersebut. Anda tidak dapat mengakses layanan dari <ClusterIP>:spec.ports[*].nodePort.

LoadBalancer memperlihatkan hal-hal berikut:

• spec.loadBalancerIp:spec.ports[*].port
• <NodeIP>:spec.ports[*].nodePort
• spec.clusterIp:spec.ports[*].port

Anda dapat mengakses layanan ini dari alamat IP penyeimbang beban Anda, yang merutekan permintaan Anda ke nodePort, yang kemudian merutekan permintaan ke port clusterIP. Anda dapat mengakses layanan ini seperti halnya NodePort atau layanan ClusterIP juga.

Untuk memperjelas bagi siapa saja yang mencari apa perbedaan antara 3 pada tingkat yang lebih sederhana. Anda dapat mengekspos layanan Anda dengan ClusterIp minimal (dalam kluster k8s) atau eksposur yang lebih besar dengan NodePort (dalam kluster eksternal ke kluster k8s) atau LoadBalancer (dunia eksternal atau apa pun yang Anda tetapkan dalam LB).

Eksposur ClusterIp <Eksposur NodePort <Eksposur LoadBalancer

• ClusterIp
  Paparkan layanan melalui k8s cluster denganip/name:port
• Layanan NodePort
  Expose melalui jaringan Internal, VM juga eksternal untuk k8sip/name:port
• LoadBalancer
  Paparkan layanan melalui dunia Eksternal atau apa pun yang Anda tetapkan dalam LB.

ClusterIP: Layanan dapat dijangkau oleh pod / layanan di Cluster
Jika saya membuat layanan yang disebut myservice di namespace tipe standar: ClusterIP maka alamat DNS statis yang dapat diprediksi berikut untuk layanan akan dibuat:

myservice.default.svc.cluster.local (atau hanya myservice.default, atau dengan pod di namespace default, "myservice" akan berfungsi)

Dan nama DNS itu hanya bisa diselesaikan oleh pod dan layanan di dalam cluster.

NodePort: Layanan dapat dijangkau oleh klien di LAN / klien yang sama yang dapat melakukan ping ke Node Host K8 (dan pod / layanan di cluster) (Catatan untuk keamanan node host K8 Anda harus berada di subnet pribadi, sehingga klien di internet memenangkan dapat menjangkau layanan ini)
Jika saya membuat layanan yang disebut mynodeportservice di mynamespace namespace type: NodePort pada 3 Node Kubernetes Cluster. Kemudian Layanan tipe: ClusterIP akan dibuat dan akan dapat dijangkau oleh klien di dalam cluster di alamat DNS statis yang dapat diprediksi berikut:

mynodeportservice.mynamespace.svc.cluster.local (atau hanya mynodeportservice.mynamespace)

Untuk setiap port yang mendengarkan mynodeportservice pada nodeport di kisaran 30000 - 32767 akan dipilih secara acak. Sehingga klien eksternal yang berada di luar cluster dapat menekan layanan ClusterIP yang ada di dalam cluster. Katakanlah bahwa node host 3 K8 kami memiliki IP 10.10.10.1, 10.10.10.2, 10.10.10.3, layanan Kubernetes mendengarkan pada port 80, dan Nodeport yang dipilih secara acak adalah 31852.

Klien yang ada di luar cluster dapat mengunjungi 10.10.10.1:31852, 10.10.10.2:31852, atau 10.10.10.3:31852 (saat NodePort didengarkan oleh setiap Node Host Kubernet) Kubeproxy akan meneruskan permintaan ke port mynodeportservice 80.

LoadBalancer: Layanan dapat dijangkau oleh semua orang yang terhubung ke internet * (Arsitektur umum adalah L4 LB dapat diakses secara publik di internet dengan meletakkannya di DMZ atau memberikannya IP privat dan publik dan node host k8s berada pada subnet pribadi)
( Catatan: Ini adalah satu-satunya jenis layanan yang tidak bekerja di 100% dari implementasi Kubernetes, seperti Kubernetes bare metal, ini berfungsi ketika Kubernetes memiliki integrasi penyedia cloud.)

Jika Anda membuat layanan mylbser, maka L4 LB VM akan muncul (layanan IP cluster, dan Layanan NodePort juga akan muncul secara implisit). Kali ini NodePort kami adalah 30222. Idenya adalah bahwa L4 LB akan memiliki IP publik 1.2.3.4 dan akan memuat keseimbangan dan meneruskan lalu lintas ke node host 3 K8 yang memiliki alamat IP pribadi. (10.10.10.1:30222, 10.10.10.2:30222, 10.10.10.3:30222) dan kemudian Kube Proxy akan meneruskannya ke layanan tipe ClusterIP yang ada di dalam cluster.

Anda juga bertanya: Apakah tipe layanan NodePort masih menggunakan ClusterIP? Ya *
Atau apakah NodeIP sebenarnya IP yang ditemukan ketika Anda menjalankan kubectl mendapatkan node? Juga Ya *

Mari kita menggambar paralel antara Fundamental:
Wadah ada di dalam pod. sebuah pod ada di dalam replaset. sebuah replika berada di dalam penyebaran.
Sama halnya:
Layanan ClusterIP adalah bagian dari Layanan NodePort. Layanan NodePort adalah Bagian dari Layanan Penyeimbang Beban.

Dalam diagram yang Anda tunjukkan, Klien akan menjadi pod di dalam kluster.

Mari kita asumsikan Anda membuat VM Ubuntu di mesin lokal Anda. Alamat IP-nya adalah 192.168.1.104 .

Anda masuk ke VM, dan menginstal Kubernetes. Kemudian Anda membuat pod tempat gambar nginx berjalan di atasnya.

1- Jika Anda ingin mengakses pod nginx ini di dalam VM Anda, Anda akan membuat ClusterIP terikat ke pod itu misalnya:

$ kubectl expose deployment nginxapp --name=nginxclusterip --port=80 --target-port=8080

Kemudian pada browser Anda, Anda dapat mengetik alamat ip nginxclusterip dengan port 80, seperti:

http://10.152.183.2:80

2- Jika Anda ingin mengakses pod nginx ini dari mesin host Anda, Anda harus mengekspos penyebaran Anda dengan NodePort . Sebagai contoh:

$ kubectl expose deployment nginxapp --name=nginxnodeport --port=80 --target-port=8080 --type=NodePort

Sekarang dari mesin host Anda, Anda dapat mengakses ke nginx seperti:

http://192.168.1.104:31865/

Di dasbor saya mereka muncul sebagai:

Di bawah ini adalah diagram yang menunjukkan hubungan dasar.

Sekalipun pertanyaan ini sudah memiliki jawaban, saya akan berikan yang lain, mungkin dengan beberapa gambar lagi untuk memiliki pemahaman yang lebih baik.

1. ClusterIP itu adalah tipe layanan default di Kubernetes dan tipe ini memberi Anda layanan di dalam cluster. Dengan menggunakan ini, aplikasi lain dari cluster dapat mengakses layanan melalui proxy Kubernetes.

Saya harus menyebutkan bahwa jenis layanan ini tidak boleh digunakan untuk mengekspos layanan produksi. Namun, itu bisa digunakan untuk

• integrasi debugging antar layanan;
• mengakses layanan internal yang mengekspos data terkait non-bisnis (dasbor pemantauan).

Cara permintaannya adalah sebagai berikut: traffic -> proxy K8s -> layanan K8s (ClusterIP) -> pods dan ditampilkan pada gambar berikut.

2. NodePort adalah cara paling primitif untuk menerima lalu lintas eksternal dan meneruskannya ke layanan kubernetes. Sesuai namanya, tipe layanan NodePort membuka port spesifik pada semua Mesin Virtual, yang notabene adalah node Kubernetes, untuk membiarkan lalu lintas yang dikirim ke port spesifik tersebut untuk diteruskan ke layanan.

Jenis layanan NodePort memiliki beberapa kelemahan:

• perlu hanya memiliki satu layanan per port;
• jika ip dari mesin virtual akan diubah, beberapa perubahan harus dilakukan di cluster;
• hanya port antara 3000-32767 yang dapat digunakan.

Cara permintaannya adalah sebagai berikut: traffic -> port terpapar pada mesin virtual -> layanan K8 (NodePort) -> pod dan ditampilkan pada gambar berikut:

3. LoadBalancer adalah cara standar untuk mengekspos layanan ke internet. Jika keinginan Anda adalah untuk secara langsung mengekspos suatu layanan dan semua lalu lintas pada port tertentu untuk diteruskan ke layanan, maka ini adalah cara untuk melakukannya. Juga, jenis layanan LoadBalancer tidak melibatkan penyaringan atau perutean apa pun. Anda juga dapat mengirim lalu lintas TCP, UDP, HTTP gRPC ke sana.

Kelemahan: setiap layanan yang diekspos melalui LoadBalancer akan memiliki alamat IP sendiri dan setiap layanan akan diekspos melalui LoadBalancer tunggal yang bisa menjadi mahal.

Permintaan memiliki jalur berikut: traffic -> LoadBalancer -> K8s Service -> pods dan ditampilkan pada gambar berikut.

1. clusterIP: IP dapat diakses di dalam cluster (lintas node dalam d cluster).

nodeA : pod1 => clusterIP1, pod2 => clusterIP2
nodeB : pod3 => clusterIP3.

pod3 dapat berbicara dengan pod1 melalui jaringan clusterIP mereka.

2. nodeport: untuk membuat pod diakses dari luar cluster melalui nodeIP: nodeport, itu akan membuat / menjaga clusterIP di atas sebagai jaringan clusterIP-nya.

nodeA => nodeIPA : nodeportX
nodeB => nodeIPB : nodeportX

Anda dapat mengakses layanan di pod1 baik melalui nodeIPA: nodeportX ATAU nodeIPB: nodeportX. Apa pun caranya akan berhasil karena kube-proxy (yang dipasang di setiap node) akan menerima permintaan Anda dan mendistribusikannya [redirect (istilah iptables)] di seluruh node menggunakan jaringan clusterIP.

3. Load balancer

pada dasarnya hanya menempatkan LB di depan, sehingga lalu lintas masuk didistribusikan ke nodeIPA: nodeportX dan nodeIPB: nodeportX kemudian lanjutkan dengan proses aliran nomor 2 di atas.