Ricerca nel sito web

Come configurare Kubernetes Cluster con Kubeadm su Debian 11


Su questa pagina

  1. Prerequisiti
  2. Impostazione dei sistemi
  3. Imposta il file /etc/hosts
  4. Imposta firewall UFW
  5. Abilita moduli kernel e disabilita SWAP
  6. Installazione di Container Runtime: CRI-O
  7. Installazione dei pacchetti Kubernetes
  8. Inizializzazione del piano di controllo Kubernetes
  9. Aggiunta di nodi di lavoro a Kubernetes
  10. Distribuzione del pod Nginx su cluster Kubernetes
  11. Conclusione

Kubernetes o k8s è una piattaforma open source per l'orchestrazione dei container che automatizza le distribuzioni, la gestione e il ridimensionamento delle applicazioni containerizzate. Kubernetes è un'orchestrazione di container creata da Google e ora è diventata un progetto open source e diventa uno standard per le moderne piattaforme di distribuzione di applicazioni e elaborazione.

Kubernetes è la soluzione per la moderna era di distribuzione dei container. Fornisce rilevamento e bilanciamento del carico dei servizi, orchestrazione dell'archiviazione, rollout e rollback automatizzati, servizio di riparazione automatica, gestione dei segreti e della configurazione. Kubernetes consente uno sviluppo nativo del cloud a costi contenuti.

In questo tutorial, configurerai il cluster Kubernetes:

  • Impostazione dei sistemi, che include: installazione del file /etc/hosts, abilitazione dei moduli del kernel e disabilitazione di SWAP.
  • Impostazione del firewall UFW aggiungendo alcune porte necessarie per Kubernetes e CNI Plugin (Calico).
  • Installazione di CRI-O come runtime del container per Kubernetes.
  • Installazione di pacchetti Kubernetes come kubelet, kubeadm e kubectl.
  • Inizializzazione di un nodo del piano di controllo e aggiunta di due nodi di lavoro.

Prerequisiti

Per completare questo tutorial, avrai bisogno dei seguenti requisiti:

  • Tre o più server Debian 11.
  • Un utente non root con privilegi di root/amministratore.

Installazione di sistemi

Prima di iniziare a installare qualsiasi pacchetto per la distribuzione di Kubernetes, dovrai configurare tutti i tuoi sistemi come richiesto per la distribuzione di Kubernetes. Ciò include le seguenti configurazioni:

  1. Imposta il file /etc/hosts corretto: ogni nome host del server deve essere risolto nell'indirizzo IP corretto. Questo può essere fatto in diversi modi, ma il più facile e semplice è usare il file /etc/hosts su tutti i server.
  2. Imposta firewall UFW: per l'ambiente di produzione, è sempre consigliabile abilitare il firewall sia sul piano di controllo che sui nodi di lavoro. Configura un firewall UFW per il piano di controllo Kubernetes, il nodo di lavoro e il plug-in CNI Calico.
  3. Abilita i moduli del kernel: Kubernetes richiedeva l'abilitazione di alcuni moduli del kernel sul sistema Linux. I moduli del kernel \overlay\ e \br_netfilter\ sono necessari per consentire a iptables di vedere i traffici con bridge.
  4. Disabilita SWAP: questo è obbligatorio, devi disabilitare SWAP su tutti i nodi Kubernetes, sia sul piano di controllo che sui nodi di lavoro. In caso contrario, il servizio kubelet verrà eseguito con problemi.

Imposta il file /etc/hosts

In questo primo passaggio, imposterai il nome host del sistema e il file /etc/hosts su tutti i tuoi server. Per questa dimostrazione, utilizzeremo i seguenti server.

Hostname        IP Address        Used as
--------------------------------------------
k8s-master      192.168.5.10      control-plane
k8s-worker1     192.168.5.115     worker node
k8s-worker2     192.168.5.116     worker node

Eseguire il seguente comando hostnamectl di seguito per configurare il nome host del sistema su ciascun server.

Per il nodo del piano di controllo, esegui il seguente comando per impostare il nome host del sistema su \k8s-master\.

sudo hostnamectl set-hostname k8s-master

Per i nodi di lavoro Kubernetes, esegui il seguente comando hostnamectl.

# setup hostname k8s-worker1
sudo hostnamectl set-hostname k8s-worker1

# setup hostname k8s-worker2
sudo hostnamectl set-hostname k8s-worker2

Successivamente, modifica il file /etc/hosts su tutti i server utilizzando il seguente comando.

sudo nano /etc/hosts

Aggiungere la seguente configurazione al file. Assicurati che ogni nome host punti all'indirizzo IP corretto.

192.168.5.10 k8s-master
192.168.5.115 k8s-worker1
192.168.5.116 k8s-worker2

Salva e chiudi il file quando hai finito.

Infine, se si esegue il comando ping su ciascun nome host, verrà indirizzato all'indirizzo IP corretto come definito nel file /etc/hosts.

ping k8s-master -c3
ping k8s-worker1
ping k8s-worker2 -c3

Configura il firewall UFW

Kubernetes richiedeva che alcune porte fossero aperte su tutti i tuoi sistemi. Sul sistema Ubuntu predefinito, il firewall UFW viene utilizzato come firewall predefinito. Installerai il firewall UFW su tutti i tuoi sistemi Debian e aggiungerai alcune regole UFW per la distribuzione di Kubernetes.

Per il piano di controllo Kubernetes, devi aprire le seguenti porte:

Protocol  Direction Port Range  Purpose Used By
-----------------------------------------------
TCP       Inbound   6443        Kubernetes API server All
TCP       Inbound   2379-2380   etcd server client API  kube-apiserver, etcd
TCP       Inbound   10250       Kubelet API Self, Control plane
TCP       Inbound   10259       kube-scheduler  Self
TCP       Inbound   10257       kube-controller-manager Self

Per i nodi di lavoro Kubernetes, devi aprire le seguenti porte:

Protocol  Direction Port Range  Purpose Used By
--------------------------------------------------
TCP       Inbound   10250       Kubelet API Self, Control plane
TCP       Inbound   30000-32767 NodePort Services†  All

In questo esempio, utilizzeremo Calico come plug-in CNI (Container Network Interface). Quindi, aprirai alcune porte aggiuntive di seguito:

Protocol  Direction          Port Range  Purpose Used By
-------------------------------------------------------
TCP       Bidirectional      179         Calico networking (BGP)
UDP       Bidirectional      4789        Calico networking with VXLAN enabled
TCP       Incoming           2379        etcd datastore
UDP       Bidirectional      4789        flannel networking (VXLAN)

Installa il pacchetto UFW sui tuoi server Debian usando il seguente comando apt. Immettere Y per confermare l'installazione e premere INVIO e l'installazione avrà inizio.

sudo apt install ufw

Successivamente, aggiungi l'applicazione OpenSSH al firewall utilizzando il comando seguente. Quindi, abilita il firewall UFW. Quando viene richiesta la conferma, immettere \y\ per abilitare ed eseguire il firewall UFW.

sudo ufw allow "OpenSSH"
sudo ufw enable

Sul nodo del piano di controllo \k8s-master\, esegui il seguente comando ufw per aprire le porte. Quindi, controlla e verifica le regole UFW.

Regole del firewall per il piano di controllo Kubernetes.

sudo ufw allow 6443/tcp
sudo ufw allow 2379:2380/tcp
sudo ufw allow 10250/tcp
sudo ufw allow 10259/tcp
sudo ufw allow 10257/tcp

Regole del firewall per il plug-in Calico CNI.

sudo ufw allow 179/tcp
sudo ufw allow 4789/udp
sudo ufw allow 4789/tcp
sudo ufw allow 2379/tcp

sudo ufw status

Sui nodi di lavoro \k8s-worker1\ e \k8s-worker2\, esegui il seguente comando ufw per aprire alcune porte. Quindi, controlla le regole del firewall UFW.

Regole firewall per i nodi di lavoro Kubernetes.

sudo ufw allow 10250/tcp
sudo ufw allow 30000:32767/tcp

Regole del firewall per Calico sui nodi di lavoro Kubernetes.

sudo ufw allow 179/tcp
sudo ufw allow 4789/udp
sudo ufw allow 4789/tcp
sudo ufw allow 2379/tcp
sudo ufw status

Abilita i moduli kernel e disabilita SWAP

Kubernetes richiedeva che i moduli del kernel \overlay\ e \br_netfilter\ fossero abilitati su tutti i server. Ciò consentirà agli iptbales di vedere i traffici con bridge. Inoltre, dovrai abilitare il port forwarding e disabilitare lo SWAP.

Eseguire il seguente comando per abilitare i moduli del kernel \overlay\ e \br_netfilter\.

sudo modprobe overlay
sudo modprobe br_netfilter

Per renderlo permanente, crea il file di configurazione in \/etc/modules-load.d/k8s.conf\ usando il comando seguente. Ciò consentirà ai sistemi Linux di abilitare i moduli del kernel durante l'avvio del sistema.

cat <<EOF | sudo tee /etc/modules-load.d/k8s.conf
overlay
br_netfilter
EOF

Successivamente, crea i parametri systemctl richiesti utilizzando il seguente comando.

cat <<EOF | sudo tee /etc/sysctl.d/k8s.conf
net.bridge.bridge-nf-call-iptables  = 1
net.bridge.bridge-nf-call-ip6tables = 1
net.ipv4.ip_forward                 = 1
EOF

Per applicare la nuova configurazione di sysctl senza riavviare, utilizzare il comando sysctl di seguito. Dovresti ottenere l'elenco dei parametri sysctl predefiniti sul tuo sistema e assicurarti di ottenere i parametri sysctl che hai appena aggiunto nel file \k8s.conf\.

sudo sysctl --system

Per disabilitare SWAP, dovrai commentare la configurazione di SWAP nel file \/etc/fstab\. Questo può essere fatto utilizzando il singolo comando tramite sed (editor di stream) o modificando manualmente il file /etc/fstab.

sudo sed -i '/ swap / s/^\(.*\)$/#\1/g' /etc/fstab

o

sudo nano /etc/fstab

Successivamente, disattiva lo SWAP nella sessione corrente utilizzando il comando seguente. Quindi, verifica che lo SWAP sia disattivato utilizzando il comando \free -m\. Dovresti vedere che lo SWAP ha valori \0\, il che significa che ora è disabilitato.

sudo swapoff -a
free -m

Installazione di Container Runtime: CRI-O

Per configurare Kubernetes Cluster, devi installare il runtime del container su tutti i server in modo che i pod possano essere eseguiti. È possibile utilizzare più runtime di container per le distribuzioni di Kubernetes come containerd, CRI-O, Mirantis Container Runtime e Docker Engine (tramite cri-dockerd).

In questa dimostrazione, utilizzeremo \CRI-O\ come contenitore per il nostro deployment Kubernetes. Quindi, installerai CRI-O su tutti i server, il piano di controllo e i nodi di lavoro.

Prima di installare CRI-O, eseguire il comando apt di seguito per installare il pacchetto base \gnupg2\ e \apt-transport-https\. Immettere Y per confermare l'installazione e premere INVIO.

sudo apt install gnupg2 apt-transport-https

Ora crea una nuova variabile di ambiente per l'installazione di CRI-O. La variabile \$OS\ con il valore \Debian_11\ e la variabile \$VERSION\ con il valore \1.24\. In questo esempio, installeremo il contenitore CRI-O v1.24 (versione corrente) per i sistemi \Debian_11\.

export OS=Debian_11
export VERSION=1.24

Eseguire il seguente comando per aggiungere il repository CRI-O per il sistema Debian 11.

echo "deb [signed-by=/usr/share/keyrings/libcontainers-archive-keyring.gpg] https://download.opensuse.org/repositories/devel:/kubic:/libcontainers:/stable/$OS/ /" > /etc/apt/sources.list.d/devel:kubic:libcontainers:stable.list
echo "deb [signed-by=/usr/share/keyrings/libcontainers-crio-archive-keyring.gpg] https://download.opensuse.org/repositories/devel:/kubic:/libcontainers:/stable:/cri-o:/$VERSION/$OS/ /" > /etc/apt/sources.list.d/devel:kubic:libcontainers:stable:cri-o:$VERSION.list

Eseguire il seguente comando per aggiungere la chiave GPG per il repository CRI-O.

mkdir -p /usr/share/keyrings
curl -L https://download.opensuse.org/repositories/devel:/kubic:/libcontainers:/stable/$OS/Release.key | gpg --dearmor -o /usr/share/keyrings/libcontainers-archive-keyring.gpg
curl -L https://download.opensuse.org/repositories/devel:/kubic:/libcontainers:/stable:/cri-o:/$VERSION/$OS/Release.key | gpg --dearmor -o /usr/share/keyrings/libcontainers-crio-archive-keyring.gpg

Ora aggiorna i repository di sistema e aggiorna l'indice del pacchetto utilizzando il comando seguente. Dovresti vedere che il repository CRI-O è stato aggiunto ai server Debian 11.

sudo apt update

Per installare il runtime del contenitore CRI-O, eseguire il seguente comando apt. Immettere Y per confermare l'installazione e premere INVIO per avviare l'installazione CRI-O.

sudo apt install cri-o cri-o-runc cri-tools

Al termine dell'installazione, modifica la configurazione CRI-O \/etc/crio/crio.conf\ utilizzando il comando seguente.

sudo nano /etc/crio/crio.conf

Nella sezione \[crio.network]\, rimuovere il commento dall'opzione \network_dir\ e da \plugin_dir\.

# The crio.network table containers settings pertaining to the management of
# CNI plugins.
[crio.network]

# The default CNI network name to be selected. If not set or "", then
# CRI-O will pick-up the first one found in network_dir.
# cni_default_network = ""

# Path to the directory where CNI configuration files are located.
network_dir = "/etc/cni/net.d/"

# Paths to directories where CNI plugin binaries are located.
plugin_dirs = [
        "/opt/cni/bin/",
]

Quando hai finito, salva e chiudi il file.

Successivamente, modifica la configurazione del bridge CRI-O \/etc/cni/net.d/100-crio-bridge.conf\ utilizzando il comando seguente.

sudo nano /etc/cni/net.d/100-crio-bridge.conf

Modifica la sottorete predefinita dell'indirizzo IP utilizzando la tua sottorete personalizzata. Questo indirizzo IP della sottorete verrà utilizzato per i tuoi pod nel cluster Kubernetes. Inoltre, dovrai assicurarti che l'indirizzo IP della sottorete corrisponda alla configurazione dell'indirizzo IP sul plug-in CNI.

In questo esempio, utilizzeremo l'indirizzo IP della sottorete \10.42.0.0/24\ per i pod nel cluster Kubernetes.

...
        "ranges": [
            [{ "subnet": "10.42.0.0/24" }],
            [{ "subnet": "1100:200::/24" }]
        ]
...

Salva e chiudi il file quando hai finito.

Eseguire quindi il seguente comando systemctl per riavviare il servizio CRI-O e applicare le nuove modifiche.

sudo systemctl restart crio

Infine, abilita l'esecuzione del servizio CRI-O all'avvio del sistema. Quindi, controlla e verifica lo stato del servizio CRI-O. E dovresti vedere che il servizio CRI-O è abilitato e lo stato corrente è in esecuzione.

sudo systemctl enable crio
sudo systemctl status crio

Installazione dei pacchetti Kubernetes

Hai installato il runtime del contenitore CRI-O. Ora installerai i pacchetti Kubernetes su tutti i tuoi sistemi Debian. Ciò include kubeadm per il bootstrap del cluster Kubernetes, kubelet il componente principale del cluster Kubernetes e kubectl l'utilità della riga di comando per la gestione del cluster Kubernetes.

In questo esempio, installeremo i pacchetti Kubernetes utilizzando il repository fornito da Kubernetes. Quindi, aggiungerai il repository Kubernetes a tutti i tuoi sistemi Debian.

Esegui il seguente comando per aggiungere il repository Kubernetes e la chiave GPG.

sudo curl -fsSLo /usr/share/keyrings/kubernetes-archive-keyring.gpg https://packages.cloud.google.com/apt/doc/apt-key.gpg
echo "deb [signed-by=/usr/share/keyrings/kubernetes-archive-keyring.gpg] https://apt.kubernetes.io/ kubernetes-xenial main" | sudo tee /etc/apt/sources.list.d/kubernetes.list

Aggiorna e aggiorna il tuo repository Ubuntu e l'indice dei pacchetti.

sudo apt update

Al termine dell'aggiornamento, installa i pacchetti Kubernetes utilizzando il seguente comando apt. Immettere Y per confermare l'installazione e premere INVIO per continuare e l'installazione avrà inizio.

sudo apt install kubelet kubeadm kubectl

Al termine dell'installazione, esegui il comando seguente per bloccare la versione corrente dei pacchetti Kubernetes. Ciò impedirà l'aggiornamento automatico dei pacchetti Kubernetes e la differenza di versione tra i pacchetti Kubernetes.

sudo apt-mark hold kubelet kubeadm kubectl

Inizializzazione del piano di controllo Kubernetes

Hai completato tutte le dipendenze e i requisiti per la distribuzione del cluster Kubernetes. Ora avvierai il cluster Kubernetes inizializzando il nodo del piano di controllo per la prima volta. In questo esempio, Kubernetes Control Plane verrà installato sul server \k8s-master\ con l'indirizzo IP \192.168.5.10\.

Prima di inizializzare il nodo Control Plane, eseguire il seguente comando per verificare che i moduli del kernel \br_netfilter\ siano abilitati. Se ottieni un output dal comando, significa che il modulo \br_netfilter\ è abilitato.

lsmod | grep br_netfilter

Successivamente, esegui il comando seguente per scaricare le immagini necessarie per il cluster Kubernetes. Questo comando scaricherà tutte le immagini del contenitore necessarie per la creazione del cluster Kubernetes come coredns, kube-api server, etcd, kube-controller, kube-proxy e l'immagine del contenitore di pausa.

sudo kubeadm config images pull

Al termine del download, esegui il comando \crictl\ qui sotto per controllare l'elenco delle immagini disponibili sul server \k8s-master\. Dovresti vedere l'elenco delle immagini che verranno utilizzate per creare il cluster Kubernetes.

sudo crictl images

Successivamente, esegui il seguente comando \kubeadm init\ per inizializzare il cluster Kubernetes sul server \k8s-master\. Questo nodo \k8s-master\ verrà selezionato automaticamente come piano di controllo Kubernetes perché questa è la prima volta che inizializza il cluster.

Inoltre, in questo esempio, specifichiamo la rete per i pod su \10.42.0.0/24\, che è la stessa sottorete della configurazione del bridge CRI-O \/etc/cni/net.d/100 -crio-bridge.conf\.
\--apiserver-advertise-address\ determina in quale indirizzo IP verrà eseguito il server API Kubernetes, questo esempio utilizza l'indirizzo IP interno \192.168.5.10\.
Per l'opzione \--cri-socket\, specifichiamo il socket CRI al socket di runtime del contenitore CRI-O disponibile su \/var/run/crio/crio.sock\. Se stai utilizzando Container Runtime diverso, devi modificare il percorso del file socket oppure puoi semplicemente rimuovere questa opzione \--cri-socket\ perché kubeadm rileverà il Container Runtime presa automaticamente.

sudo kubeadm init --pod-network-cidr=10.42.0.0/24 \
--apiserver-advertise-address=192.168.5.10 \
--cri-socket=unix:///var/run/crio/crio.sock

Di seguito è riportato l'output quando si inizializza il cluster Kubernetes sul server \k8s-master\.

Al termine dell'inizializzazione, puoi visualizzare un messaggio del tipo \Il tuo piano di controllo Kubernetes è stato inizializzato correttamente!\ con alcuni importanti messaggi di output per l'impostazione delle credenziali Kubernetes e la distribuzione del componente aggiuntivo di rete Pod, la procedura per aggiungere il nodo di lavoro al tuo cluster Kubernetes.

Prima di iniziare a gestire il cluster Kubernetes con lo strumento \kubectl\, dovrai configurare le credenziali Kubernetes. Esegui il comando seguente per configurare le credenziali Kubernetes.

mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config

Ora puoi utilizzare il comando \kubectl\ per interagire con il tuo cluster Kubernetes. Esegui il seguente comando \kubectl\ per verificare le informazioni sul cluster Kubernetes. E dovresti vedere il piano di controllo Kubernetes e i core in esecuzione.

kubectl cluster-info

Per ottenere informazioni complete sul tuo Kubernetes, puoi utilizzare l'opzione dump, quindi \kubectl cluster-info dump\.

Dopo che Kubernetes è in esecuzione, configurerai il plug-in Calico CNI per il tuo cluster Kubernetes. Esegui il seguente comando per scaricare il file manifest di Calico \calico.yaml\. Quindi, modifica il file \calico.yaml\ utilizzando nano editor.

curl https://docs.projectcalico.org/manifests/calico.yaml -O
nano calico.yaml

Rimuovere il commento dalla configurazione \CALICO_IPV4POOL_CIDR\ e modificare la subnet di rete in \10.42.0.0/24\. Questa configurazione della sottorete deve essere la stessa della configurazione del bridge CRI-O e della configurazione \--pod-network-cidr\ durante l'inizializzazione di Kubernetes utilizzando il comando \kubeadm init\.

...
            - name: CALICO_IPV4POOL_CIDR
              value: "10.42.0.0/24"
...

Quando hai finito, salva e chiudi il file.

Successivamente, esegui il comando \kubectl\ di seguito per distribuire il plug-in Calico CNI con il file manifest personalizzato \calico.yaml\. Questo comando creerà più risorse Kubernetes per il plug-in Calico CNI. Inoltre, questo scaricherà le immagini di Calico e creerà nuovi pod per Calico.

sudo kubectl apply -f calico.yml

Ora esegui il seguente comando kubectl di seguito per controllare i pod disponibili sul tuo cluster Kubernetes. Dovresti vedere due pod aggiuntivi \calico-node-xxx\ e \calico-kube-controller-xxx\.

kubectl get pods --all-namespaces

Aggiunta di nodi di lavoro a Kubernetes

Dopo aver inizializzato il piano di controllo Kubernetes sul server \k8s-master\, aggiungerai i nodi di lavoro \k8s-worker1\ e \k8s-worker2\ al cluster Kubernetes.

Passa al server \k8s-worker1\ ed esegui il comando \kubeadm join\ seguente per aggiungere \k8s-worker1\ al cluster Kubernetes. Potresti avere token e hash ca-cert diversi, puoi vedere i dettagli di queste informazioni sul messaggio di output quando inizializzi il nodo del piano di controllo.

kubeadm join 192.168.5.10:6443 --token dbgk8h.nwzqqp1v5aqif5fy \
        --discovery-token-ca-cert-hash sha256:7a543a545585358b143ce3e8633a8d673b6f628c5abc995939a58606c6dd219c

Nel seguente output, puoi vedere che il server \k8s-worker1\ è unito dal cluster Kubernetes.

Successivamente, passa al server \k8s-worker2\ ed esegui il comando \kubeadm join\ per aggiungere \k8s-worker2\ al cluster Kubernetes.

kubeadm join 192.168.5.10:6443 --token dbgk8h.nwzqqp1v5aqif5fy \
        --discovery-token-ca-cert-hash sha256:7a543a545585358b143ce3e8633a8d673b6f628c5abc995939a58606c6dd219c

Vedrai lo stesso messaggio di output al termine del processo.

Ora torna al server del piano di controllo k8s-master\ ed esegui il seguente comando per controllare tutti i pod in esecuzione sul cluster Kubernetes. Dovresti vedere che ci sono pod aggiuntivi per ogni componente Kubernetes su tutti gli spazi dei nomi.

kubectl get pods --all-namespaces

o

kubectl get pods -o wide --all-namespaces

Infine, controlla e verifica tutti i nodi disponibili sul cluster Kubernetes utilizzando il comando kubectl\ di seguito. Dovresti vedere che il server cplane1\ è in esecuzione come piano di controllo Kubernetes e \k8s-worker1\ e \k8s- i server worker2\ sono in esecuzione come nodo di lavoro.

kubectl get nodes -o wide

Distribuzione di Nginx Pod su Kubernetes Cluster

Eseguire il comando seguente per creare una nuova distribuzione per il server Web Nginx. In questo esempio, creeremo nuovi pod Nginx basati sull'immagine \nginx:alpine\ con due repliche.

kubectl create deployment nginx --image=nginx:alpine --replicas=2

Ora crea un nuovo tipo di servizio \NodePort\ che esporrà la distribuzione Nginx utilizzando il seguente comando kubectl. Questo comando creerà un nuovo servizio Kubernetes denominato \nginx\ con il tipo \NodePort\ ed esporrà la porta \80\ per il pod.

kubectl create service nodeport nginx --tcp=80:80

Successivamente, esegui il seguente comando kubectl per controllare l'elenco dei pod in esecuzione sul tuo cluster Kubernetes. E dovresti vedere due pod Nginx in esecuzione.

kubectl get pods

Ora controlla l'elenco dei servizi disponibili su Kubernetes usando il seguente comando. Dovresti vedere il tipo di servizio \nginx\ NodePort esposto la porta \80\ e la porta \31277\ sugli host Kubernetes. Il servizio NodePort esporrà sempre la porta nell'intervallo 30000-32767.

kubectl get svc

Esegui il comando curl di seguito per accedere alla tua distribuzione Nginx.

curl k8s-worker1:31277
curl k8s-worker2:31277

Di seguito è riportato l'output del codice sorgente index.html dal nodo \k8s-worker1\.

E sotto c'è il codice index.html dal nodo \k8s-worker2\.

Conclusione

Durante questo tutorial, hai terminato la distribuzione del cluster Kubernetes con tre nodi e server Debian 11. Il cluster Kubernetes è in esecuzione con un piano di controllo e due nodi di lavoro. È in esecuzione con CRI-O come container runtime per il tuo cluster Kubernetes e il plug-in Calico CNI per il collegamento in rete dei pod sul tuo cluster. Inoltre, hai distribuito correttamente il server Web Nginx all'interno del cluster Kubernetes.

Hai configurato Kubernetes Cluster completamente, puoi iniziare a distribuire le tue applicazioni nel cluster Kubernetes o provare a installare Kubernetes Dashboard per saperne di più sul tuo ambiente Kubernetes.