Compartilhamento de tecnologia

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

Implantação offline do K8s

ambiente

Alvo

implantação off-line k8s

etapa

Implantar janela de encaixe

Para obter detalhes, consulte o artigo: "Instalação offline do docker e empacotamento offline de projetos back-end"
https://blog.csdn.net/qq_45371023/article/details/140279746?spm=1001.2014.3001.5501
Todos os arquivos usados ​​estão em:
Link: https://pan.baidu.com/s/10cb-dXkgdShdjPEBCyvTrw?pwd=fpuy
Código de extração: fpuy

Instale cri_dockerd

1. Instale o cri_dockerd

rpm -ivh cri-dockerd-0.3.9-3.el8.x86_64.rpm

2. Recarregue o daemon do sistema → Configure o cri-dockerd para iniciar automaticamente → Inicie o cri-dockerd

Recarregar daemon do sistema

sudo systemctl daemon-reload
1

Configure o cri-dockerd para iniciar automaticamente

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

Inicie o 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: Falha ao iniciar o cri-docker

medir:

Método 1: systemctl restart docker # Reiniciar docker

Método 2: desinstale o docker, reinstale-o e execute as etapas acima novamente

*Instale o Kubernetes

Instalar o kubectl

1. Instale o kubectl

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

2. Verifique se a instalação foi concluída

kubectl version --client
1

Instale o kubeadm

3. Abra a porta ou feche o firewall (para garantir um processo de instalação tranquilo)

Porta aberta (servidor em nuvem)

Abra a porta 6443

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

Recarregar firewall

sudo firewall-cmd --reload
1

Ver todas as portas abertas

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

Ou desligue o firewall (máquina virtual)

Desativar firewall

sudo systemctl stop firewalld
1

Desative o início automático do firewall

sudo systemctl disable firewalld
1

4. Desative o SELinux (garanta que o contêiner possa acessar os recursos do sistema)

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

5. Instale kubeadm, kubelet e kubectl

Baixe o pacote de instalação offline relevante no formato rpm, que existe em 3_yum_package Use o comando para instalar todos os pacotes de instalação rpm no diretório.

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

6. Configure o kubelet para iniciar automaticamente

sudo systemctl enable --now kubelet
1

*Implantar cluster k8s

Depois de concluir as etapas acima, você terá o seguinte ambiente

·Dois servidores ou máquinas virtuais com endereços IP diferentes podem se comunicar entre si e manter o status da LAN. O endereço IP está definido como 192.168..34 e 192.168..35

·O tempo de execução do contêiner (Docker+cri_dockerd) está instalado em ambos os servidores e os componentes kubernetes kubectl, kubeadm e kubelet foram instalados.

Preparação ambiental

7. Feche a partição swap. Isso é dividido em desligamento temporário e desligamento permanente é recomendado para ambientes de máquina virtual porque será ligado e desligado com frequência.

Feche temporariamente a partição swap

swapoff -a
1

Para fechar permanentemente a partição swap, comente a linha que contém swap no fstab.

vi /etc/fstab
1

# /dev/mapper/centos-swap swap swap padrões 0 0

Reinicie para que tenha efeito. A reinicialização pode fazer com que o status do cri-dockerd seja alterado. Na implantação real, não optei por reiniciar. O motivo é que a versão ou configuração não está configurada corretamente. cri-dockerd e então inicie o cri-dockerd para fazer com que o status do cri -dockerd seja normal

reinício

8. Instale runc como ambiente operacional k8s

Instalar runc

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

#Verifique se a instalação foi bem sucedida

runc -v
1

9. Docker e cri-dockerd configuram aceleração de imagem doméstica (Como os nomes dos seguintes pacotes de software a serem usados ​​nesta pasta possuem endereços de espelho, é recomendado configurar a aceleração de espelho correspondente mesmo em uma rede local para evitar que o kubectl exija que a Internet extraia pacotes de software e ignore o espelho local após o a instalação está concluída.）

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

Reinicie os componentes do Docker

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

# Verifica o status do componente Docker

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

10. Verifique o nome do host e hosts

nó mestre

o nome do host é k8s-master

vi /etc/hostname
1

Adicionar mapeamento de nome de domínio

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

Outros nós

nome do host为k8s-slave01

vi /etc/hostname
1

Adicionar mapeamento de nome de domínio

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

11. Encaminhe o IPv4 e deixe o iptables ver o fluxo da ponte

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

Defina os parâmetros sysctl necessários, que persistem durante as reinicializações

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

#Aplica parâmetros sysctl sem reiniciar

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 o erro iptables ainda for exibido durante a inicialização, execute

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

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

Inicializar nó/mestre do plano de controle

12. Inicialize o nó mestre

Antes da inicialização, você precisa obter a imagem do docker necessária para inicialização por meio de imagens de configuração do kubeadm:

Instale a imagem docker load -i **.tar

Arquivos de imagem relevantes existem em 5_kubeadm-images.

Execute a inicialização:

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 # Substitua a fonte da imagem do contêiner baixada pelo Alibaba Cloud, caso contrário, a imagem não poderá ser retirada por motivos de rede e a execução definitivamente falhará.

–cri-socket=unix:///var/run/cri-dockerd.sock # Este é o tempo de execução do contêiner especificado, porque o containerd também é um dos componentes do Docker. O Docker também fará o download do containerd ao executar a inicialização. detectar que existem vários ambientes de tempo de execução de contêiner, ele deverá selecionar manualmente um. Também pode ser visto aqui que o containerd é na verdade muito mais leve que o Docker.

–apiserver-advertise-address=192.168.56.50 # Defina o endereço de transmissão para o servidor API. Selecione o endereço IPv4 local aqui. Se você não deseja que o API SERVER seja definido em outros nós, não altere-o para outro endereço.

–pod-network-cidr=10.244.0.0/16 # Especifique o intervalo de endereços IP que pode ser usado pela rede do pod.

–service-cidr=10.96.0.0/12 # Especifique um segmento de endereço IP adicional para o endereço IP virtual do serviço Se ainda não tiver certeza, você pode simplesmente usar esse valor independentemente.

Problema: a verificação cordns:v1.10.1 não existe, na verdade cordns:v1.10.1 já existe, mas é cordns:1.10.1.

Medidas: Modifique a etiqueta dos cordões.

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

Execute novamente o comando de inicialização

Registre as informações abaixo do kubeadm join, que é necessário para o node join. As informações relevantes para o exemplo acima são:

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

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

Se você esquecer, você pode usar a lista de tokens kubeadm para consultar O token existe por 24 horas, recriar o token kubeadm create --print-join-command e excluí-lo usando kubeadm token delete tokenid.

Usuários não-root, executem

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

O usuário root executa diretamente

Entra em vigor temporariamente e se tornará inválido após reiniciar. Não é recomendado.

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

Ele entra em vigor permanentemente. Não há necessidade de executar este comando novamente após executar kubeadm reset e init novamente.

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

Depois de executar o comando efetivo permanente, você precisa obtê-lo para torná-lo eficaz.

source ~/.bash_profile
1

Verifique se a configuração é eficaz

echo $KUBECONFIG 

/etc/kubernetes/admin.conf
1
2
3

13. Instale e configure plug-ins de rede

Aqui, flannel é usado para baixar e enviar o arquivo kube-flannel.yml para o servidor.

Carregue a imagem relevante no servidor para instalação. kube-flannel.yml e arquivos de imagem existem em 6_kube-flannel.

Consultar placa de rede

se configurar

kube-flannel.yml procurará a placa de rede enp1s0 por padrão. Neste exemplo, a placa de rede 34 é enp1s0 e não precisa ser modificada.

//Modifique kube-flannel.yml de 35 e adicione –iface=enp0s3 para especificar (enp0s3 aqui é a placa de rede correspondente ao ip, como a parte da caixa acima). As localizações dos parâmetros são as seguintes:

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

Configurando o plugin de rede flanelada para Kubernetes

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

cat /run/flannel/subnet.env
1

# Se não existir tal arquivo ou pasta, você precisará criá-lo manualmente. O conteúdo é o mesmo abaixo.

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

Nó nó se junta ao Mestre

14. Nó nó se junta ao Mestre

14.1. Copie /etc/kubernetes/admin.conf da máquina do nó mestre para a máquina do nó escravo

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

# Não se esqueça de adicionar admin.conf à variável de ambiente. Use-o diretamente aqui para ter efeito permanente.

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

source ~/.bash_profile
1
2
3

Se houver um problema durante a cópia:

A chave do host ECDSA para 192.168.55.187 foi alterada e você solicitou uma verificação rigorosa. A verificação da chave do host falhou.

Execute as seguintes instruções para reparar

ssh-keygen -R 192.168.55.187
1

14.2. Execute o comando join (após o nó mestre ser inicializado com sucesso, o comando join será dado)

Por exemplo:

kubeadm junte-se a 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.Execute nós de obtenção do kubectl

O cluster k8s foi implantado com sucesso! ! !

pergunta

Pergunta um

kubectl obter nós

Medidas: Verifique se o swap está fechado; verifique se o firewall abre a porta 6443;

Fechar troca

Desligue temporariamente o firewall

sucesso

Questão 2

kubectl obter nós

Depois de adicionar um nó k8s ao cluster, verifique se o status do nó é NotReady

medir:

systemctl restart kubelet.service

systemctl restart docker.service
1
2
3

Reinicie o kubelet e o docker

Pergunta três

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

Ocorre um tempo limite de inicialização ao adicionar nós filhos a um cluster k8s.

medir:

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

sucesso

Pergunta 4

Copie /etc/kubernetes/admin.conf da máquina do nó mestre para a máquina do nó escravo

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

Se a cópia do arquivo falhar, a mensagem de erro será a seguinte:

A chave do host ECDSA para 192.168.55.187 foi alterada e você solicitou uma verificação rigorosa.

Falha na verificação da chave do host.

Execute as seguintes instruções para reparar

ssh-keygen -R 192.168.55.187
1

Exclusão rápida

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

nó escravo

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

nó mestre

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 necessário, reinicialize o 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

nó mestre

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

nó mestre

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

nó escravo

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