Condivisione della tecnologia

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

Distribuzione offline di K8

ambiente

Bersaglio

Distribuzione offline di k8s

fare un passo

Distribuisci la finestra mobile

Per i dettagli vedere l'articolo: "Installazione offline della finestra mobile e confezionamento offline dei progetti back-end"
Italiano: https://blog.csdn.net/qq_45371023/article/details/140279746?spm=1001.2014.3001.5501
Tutti i file utilizzati si trovano in:
Collegamento: https://pan.baidu.com/s/10cb-dXkgdShdjPEBCyvTrw?pwd=fpuy
Codice di estrazione: fpuy

Installa cri_dockerd

1. Installa cri_dockerd

giri al minuto -ivh cri-dockerd-0.3.9-3.el8.x86_64.rpm

2. Ricaricare il demone di sistema → Impostare cri-dockerd per l'avvio automatico → Avvia cri-dockerd

Ricarica il demone di sistema

sudo systemctl daemon-reload
1

Imposta cri-dockerd per l'avvio automatico

sudo systemctl enable cri-docker.socket cri-docker
1

Inizia cri-dockerd

sudo systemctl start cri-docker.socket cri-docker

sudo systemctl status cri-docker.socket

sudo systemctl status cri-docker
1
2
3
4
5

Problema: impossibile avviare cri-docker

misurare:

Metodo 1: systemctl restart docker # Riavvia docker

Metodo 2: disinstallare la finestra mobile e reinstallarla, quindi eseguire nuovamente i passaggi precedenti

*Installa Kubernetes

Installa kubectl

1. Installa kubectl

sudo install -o root -g root -m 0755 kubectl /usr/local/bin/kubectl
1

2. Controlla se l'installazione è completa

kubectl version --client
1

Installa kubeadm

3. Apri la porta o chiudi il firewall (per garantire un processo di installazione regolare)

Porta aperta (server cloud)

Apri la porta 6443

sudo firewall-cmd --zone=public --add-port=6443/tcp --permanent
1

Ricarica il firewall

sudo firewall-cmd --reload
1

Visualizza tutte le porte aperte

sudo firewall-cmd --zone=public --list-ports
1

Oppure spegni il firewall (macchina virtuale)

Disattiva il firewall

sudo systemctl stop firewalld
1

Disattiva l'avvio automatico del firewall

sudo systemctl disable firewalld
1

4. Disabilita SELinux (assicurati che il contenitore possa accedere alle risorse di sistema)

sudo setenforce 0
sudo sed -i 's/^SELINUX=enforcing$/SELINUX=permissive/' /etc/selinux/config
1
2

5. Installa kubeadm, kubelet e kubectl

Scarica il pacchetto di installazione offline pertinente in formato RPM, che esiste in 3_yum_package. Utilizza il comando per installare tutti i pacchetti di installazione RPM nella directory.

cd 3_yum_package && rpm -ivh *.rpm
1

6. Imposta kubelet per l'avvio automatico

sudo systemctl enable --now kubelet
1

*Distribuisci il cluster k8s

Dopo aver completato i passaggi precedenti, avrai il seguente ambiente

·Due server o macchine virtuali con indirizzi IP diversi possono comunicare tra loro e mantenere lo stato LAN. L'indirizzo IP è impostato su 192.168..34 e 192.168..35

·Il runtime del contenitore (Docker+cri_dockerd) è installato su entrambi i server e sono stati installati i componenti Kubernetes kubectl, kubeadm e kubelet.

Preparazione ambientale

7. Chiudere la partizione di swap. Questa è divisa in arresto temporaneo e arresto permanente. Si consiglia l'arresto permanente per gli ambienti della macchina virtuale poiché verrà attivato e disattivato frequentemente. Al contrario, si consiglia l'arresto temporaneo per gli ambienti cloud.

Chiudi temporaneamente la partizione di swap

swapoff -a
1

Per chiudere permanentemente la partizione di swap, commenta la riga contenente swap in fstab.

vi /etc/fstab
1

# /dev/mapper/centos-swap swap valori predefiniti di swap 0 0

Riavviare per renderlo effettivo. Il riavvio potrebbe causare la modifica dello stato di cri-dockerd Nella distribuzione effettiva, non ho scelto di riavviare Il motivo è che la versione o la configurazione non sono configurate correttamente cri-dockerd e quindi avviare cri-dockerd per rendere lo stato cri-dockerd normale

riavviare

8. Installa runc come ambiente operativo k8s

Installa runc

sudo install -m 755 runc.amd64 /usr/local/bin/runc
1

# Controlla se l'installazione ha avuto successo

runc -v
1

9. Docker e cri-dockerd hanno creato l'accelerazione dell'immagine domestica (Poiché i nomi dei seguenti pacchetti software da utilizzare in questa cartella hanno indirizzi mirror, si consiglia di configurare l'accelerazione mirror corrispondente anche su una rete locale per evitare che kubectl richieda a Internet di estrarre pacchetti software e ignori il mirror locale dopo il l'installazione è completata.）

sudo tee /etc/docker/daemon.json <<-'EOF'

{

 "registry-mirrors": ["https://tsvqojsz.mirror.aliyuncs.com"]

}

EOF

# 找到第10行

vi /usr/lib/systemd/system/cri-docker.service

# 修改为ExecStart=/usr/bin/cri-dockerd --network-plugin=cni --pod-infra-container-image=registry.aliyuncs.com/google_containers/pause:3.9
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

Riavviare i componenti Docker

systemctl daemon-reload && systemctl restart docker cri-docker.socket cri-docker
1

# Controlla lo stato del componente Docker

systemctl status docker cir-docker.socket cri-docker
1

10. Controlla il nome host e gli host

nodo principale

il nome host è k8s-master

vi /etc/hostname
1

Aggiungi la mappatura del nome di dominio

echo "192.168.**.35 k8s-slave01">> /etc/hosts
1

Altri nodi

nome host k8s-slave01

vi /etc/hostname
1

Aggiungi la mappatura del nome di dominio

echo "192.168.**.34 k8s-master" >> /etc/hosts
1

11. Inoltrare IPv4 e lasciare che iptables veda il flusso del bridge

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

overlay

br_netfilter

EOF

 

sudo modprobe overlay

sudo modprobe br_netfilter
1
2
3
4
5
6
7
8
9
10
11
12
13

Imposta i parametri sysctl richiesti, che persistono dopo i riavvii

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
1
2
3
4
5
6
7
8
9

#Applica i parametri sysctl senza riavviare

sudo sysctl --system

 

lsmod | grep br_netfilter

lsmod | grep overlay

 

sysctl net.bridge.bridge-nf-call-iptables net.bridge.bridge-nf-call-ip6tables net.ipv4.ip_forward

1
2
3
4
5
6
7
8
9
10
11
12

# Se l'errore iptables viene ancora visualizzato durante l'inizializzazione, eseguirlo

echo "1">/proc/sys/net/bridge/bridge-nf-call-iptables

echo "1">/proc/sys/net/ipv4/ip_forward
1
2
3

Inizializza il nodo/master del piano di controllo

12. Inizializzare il nodo master

Prima dell'inizializzazione, è necessario ottenere l'immagine docker richiesta per l'inizializzazione tramite le immagini di configurazione kubeadm:

Installa la finestra mobile dell'immagine load -i **.tar

I file di immagine pertinenti esistono in 5_kubeadm-images.

Eseguire l'inizializzazione:

kubeadm init --node-name=k8s-master list--image-repository=registry.aliyuncs.com/google_containers --cri-socket=unix:///var/run/cri-dockerd.sock --apiserver-advertise-address=192.168.**.34 --pod-network-cidr=10.244.0.0/16 --service-cidr=10.96.0.0/12
1

–image-repository=registry.aliyuncs.com/google_containers # Sostituisci l'origine dell'immagine del contenitore scaricata con Alibaba Cloud In caso contrario, l'immagine non potrà essere rimossa per motivi di rete e l'esecuzione fallirà sicuramente.

–cri-socket=unix:///var/run/cri-dockerd.sock # Questo è il runtime del contenitore specificato, poiché containerd è anche uno dei componenti di Docker Download Docker scaricherà anche containerd durante l'inizializzazione rileva che sono presenti più ambienti runtime del contenitore, è necessario selezionarne uno manualmente. Si può anche vedere qui che containerd è in realtà molto più leggero di Docker.

–apiserver-advertise-address=192.168.56.50 # Imposta l'indirizzo broadcast per il server API Seleziona qui l'indirizzo IPv4 locale Se non vuoi che API SERVER sia impostato su altri nodi, non cambiarlo con un altro indirizzo.

–pod-network-cidr=10.244.0.0/16 # Specifica l'intervallo di indirizzi IP che può essere utilizzato dalla rete pod. Se non sei ancora sicuro, puoi ignorarlo e utilizzare questo valore.

–service-cidr=10.96.0.0/12 # Specifica un segmento di indirizzo IP aggiuntivo per l'indirizzo IP virtuale del servizio. Se non sei ancora sicuro, puoi semplicemente utilizzare questo valore a prescindere.

Problema: il controllo cordns:v1.10.1 non esiste, infatti cordns:v1.10.1 esiste già, ma è cordns:1.10.1.

Misure: Modificare il tag di cordns.

docker tag registry.aliyuncs.com/google_containers/coredns:1.10.1 registry.aliyuncs.com/google_containers/coredns:v1.10.1
1

Eseguire nuovamente il comando di inizializzazione

Registra le informazioni di seguito su kubeadm join, necessarie per l'unione al nodo. Le informazioni rilevanti per l'esempio precedente sono:

kubeadm join 192.168.51.34:6443 --token 1qtv3k.p8tfvdcds6x5ichf 

​    --discovery-token-ca-cert-hash sha256:90afb5751086aabf7ac90d9e77a946eb768d47ffaaead62243264641954a5e26
1
2
3

Se lo dimentichi, puoi utilizzare l'elenco dei token kubeadm per eseguire una query. Il token esiste per 24 ore, ricreare il token kubeadm create --print-join-command ed eliminarlo utilizzando il token kubeadm delete tokenid.

Gli utenti non root sono pregati di eseguire

mkdir -p $HOME/.kube

sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config

sudo chown $(id -u):$(id -g) $HOME/.kube/config
1
2
3
4
5

L'utente root esegue direttamente

Ha effetto temporaneo e non sarà più valido dopo il riavvio. Non è consigliabile.

export KUBECONFIG=/etc/kubernetes/admin.conf 
1

Ha effetto in modo permanente. Non è necessario eseguire nuovamente questo comando dopo aver eseguito nuovamente kubeadm reset e init.

echo "export KUBECONFIG=/etc/kubernetes/admin.conf" >> ~/.bash_profile 
1

Dopo aver eseguito il comando efficace permanente, è necessario procurarselo per renderlo efficace.

source ~/.bash_profile
1

Verificare se la configurazione è efficace

echo $KUBECONFIG 

/etc/kubernetes/admin.conf
1
2
3

13. Installare e configurare i plug-in di rete

Flannel viene utilizzato qui per scaricare e caricare il file kube-flannel.yml sul server.

Carica l'immagine pertinente sul server per l'installazione. kube-flannel.yml e i file di immagine esistono in 6_kube-flannel.

Interroga la scheda di rete

seconfig

kube-flannel.yml cercherà la scheda di rete enp1s0 per impostazione predefinita. In questo esempio, la scheda di rete 34 è enp1s0 e non necessita di essere modificata.

//Modifica kube-flannel.yml di 35 e aggiungi –iface=enp0s3 da specificare (enp0s3 qui è la scheda di rete corrispondente all'ip, come la parte nella casella sopra). Le posizioni dei parametri sono le seguenti:

container:

  ......

  command：

  - /opt/bin/flanneld

  arg:

  - --ip-masq

  - --kube-subnet-mgr

  - --iface=enp4s0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

Configurazione del plug-in di rete Flannel per Kubernetes

kubectl apply -f /data/k8s/6_kube-flannel/kube-flannel.yml
1

cat /run/flannel/subnet.env
1

# Se non esiste un file o una cartella di questo tipo, è necessario crearlo manualmente. Il contenuto è lo stesso riportato di seguito.

FLANNEL_NETWORK=10.244.0.0/16

FLANNEL_SUBNET=10.244.0.1/24

FLANNEL_MTU=1450

FLANNEL_IPMASQ=true
1
2
3
4
5
6
7

Il nodo del nodo si unisce al Master

14. Il nodo nodo si unisce al Master

14.1 Copiare /etc/kubernetes/admin.conf dalla macchina del nodo master alla macchina del nodo slave

scp /etc/kubernetes/admin.conf 192.168.56.51:/etc/kubernetes/
1

# Non dimenticare di aggiungere admin.conf alla variabile d'ambiente Usalo direttamente qui per avere effetto in modo permanente.

echo "export KUBECONFIG=/etc/kubernetes/admin.conf" >> ~/.bash_profile

source ~/.bash_profile
1
2
3

Se si verifica un problema durante la copia:

La chiave host ECDSA per 192.168.55.187 è cambiata e hai richiesto un controllo rigoroso. Verifica della chiave host non riuscita.

Eseguire le seguenti istruzioni per riparare

ssh-keygen -R 192.168.55.187
1

14.2. Eseguire il comando di join (dopo che il nodo master è stato inizializzato con successo, verrà dato il comando di join)

Per esempio:

kubeadm join 192.168.51.34:6443 --token by7t4x.da3f98dzrvjylykz --discovery-token-ca-cert-hash sha256:90afb5751086aabf7ac90d9e77a946eb768d47ffaaead62243264641954a5e26 --cri-socket unix:///var/run/cri-dockerd.sock

14.3. Esegui kubectl get nodes

Il cluster k8s è stato distribuito con successo! ! !

domanda

Domanda uno

kubectl ottieni nodi

Misure: verificare se lo swap è chiuso; verificare se il firewall apre la porta 6443

Chiudi lo scambio

Disattiva temporaneamente il firewall

successo

Domanda 2

kubectl ottieni nodi

Dopo aver aggiunto un nodo k8s al cluster, verifica che lo stato del nodo sia NotReady.

misurare:

systemctl restart kubelet.service

systemctl restart docker.service
1
2
3

Riavvia kubelet e la finestra mobile

Domanda tre

kubeadm join 192.168.51.34:6443 --token l2qlvh.and3fnjmzecueu9h --discovery-token-ca-cert-hash sha256:90afb5751086aabf7ac90d9e77a946eb768d47ffaaead62243264641954a5e26 --cri-socket unix:///var/run/cri-dockerd.sock

Si verifica un timeout di inizializzazione quando si aggiungono nodi secondari a un cluster k8s.

misurare:

kubeadm reset -f --cri-socket unix:///var/run/cri-dockerd.sock
1

successo

Domanda 4

Copia /etc/kubernetes/admin.conf dalla macchina del nodo master alla macchina del nodo slave

Il comando scp /etc/kubernetes/admin.conf 192.168.55.187:/etc/kubernetes/

Se la copia del file non riesce, il messaggio di errore è il seguente:

La chiave host ECDSA per 192.168.55.187 è cambiata e hai richiesto un controllo rigoroso.

Verifica della chiave host non riuscita.

Eseguire le seguenti istruzioni per riparare

ssh-keygen -R 192.168.55.187
1

Eliminazione rapida

kubectl delete node k8s-slave01
kubectl delete node k8s-slave02
kubectl delete node k8s-master
1
2
3

nodo schiavo

rm -rf /etc/kubernetes/*
kubeadm reset --cri-socket unix:///var/run/cri-dockerd.sock
1
2

nodo principale

rm -rf /etc/kubernetes/*
rm -rf ~/.kube/*
rm -rf /var/lib/etcd/*
kubeadm reset -f --cri-socket unix:///var/run/cri-dockerd.sock
1
2
3
4

Se necessario, reinizializzare il cluster k8s.

kubeadm init --node-name=k8s-master --image-repository=registry.aliyuncs.com/google_containers --cri-socket=unix:///var/run/cri-dockerd.sock --apiserver-advertise-address=192.168.51.34 --pod-network-cidr=10.244.0.0/16 --service-cidr=10.96.0.0/12
1

nodo principale

kubectl apply -f /data/k8s/6_kube-flannel/kube-flannel.yml
kubectl get pod -A
1
2

nodo principale

scp /etc/kubernetes/admin.conf 192.168.51.35:/etc/kubernetes/
scp /etc/kubernetes/admin.conf 192.168.51.36:/etc/kubernetes/
1
2

nodo schiavo

kubeadm join 192.168.51.34:6443 --token 1k9kdy.dvn2qbtd7rjar1ly 
       --discovery-token-ca-cert-hash sha256:ff90d8ed41ae1902a839194f179a1c3ba8374a5197ea3111e10e5ca1c09fa442 --cri-socket unix:///var/run/cri-dockerd.sock
1
2

kubectl get pod -A
kubectl get nodes
1
2