Instalación de Kubernetes (Ubuntu 18.4)
Ubuntu18 Ali source
-backup /etc/apt/sources.list
cp /etc/apt/sources.list /etc/apt/sources.list.bak
--Modificar fuentes domésticas Reemplace /etc/apt/sources.list con lo siguiente
deb http://mirrors.aliyun.com/ubuntu/ bionic main restricted universe multiverse
deb-src http://mirrors.aliyun.com/ubuntu/ bionic main restricted universe multiverse
deb http://mirrors.aliyun.com/ubuntu/ bionic-security main restricted universe multiverse
deb-src http://mirrors.aliyun.com/ubuntu/ bionic-security main restricted universe multiverse
deb http://mirrors.aliyun.com/ubuntu/ bionic-updates main restricted universe multiverse
deb-src http://mirrors.aliyun.com/ubuntu/ bionic-updates main restricted universe multiverse
deb http://mirrors.aliyun.com/ubuntu/ bionic-backports main restricted universe multiverse
deb-src http://mirrors.aliyun.com/ubuntu/ bionic-backports main restricted universe multiverse
deb http://mirrors.aliyun.com/ubuntu/ bionic-proposed main restricted universe multiverse
deb-src http://mirrors.aliyun.com/ubuntu/ bionic-proposed main restricted universe multiverse
-Actualizar
sudo apt-get update
Uno, instalación de Docker
1. Actualizar el software del sistema
sudo apt-get update
2. Instale las dependencias de Docker y vim net-tools openssh-server
sudo apt-get install -y vim net-tools openssh-server apt-transport-https ca-certificates curl gnupg-agent software-properties-common
3. Agregar la clave secreta oficial de Docker
sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
4. Verifique la huella digital
sudo apt-key fingerprint 0EBFCD88
5. Agregar almacén
sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"
6. Actualice el índice del paquete apt
sudo apt-get update
7. Instale la última versión de Docker.
sudo apt-get install -y docker-ce docker-ce-cli containerd.io
-Instalar la versión especificada
(1) Listar las versiones disponibles en el almacén
apt-cache madison docker-ce
(2) Instale la versión especificada. La segunda columna de la cadena es el número de versión, reemplace VERSION_STRING en el siguiente comando
sudo apt-get install docker-ce=<VERSION_STRING> docker-ce-cli=<VERSION_STRING> containerd.io
Dos, instala kubernetes
1. Cree un archivo de configuración
sudo touch /etc/apt/sources.list.d/kubernetes.list
2. Agregar permiso de escritura
sudo chmod 666 /etc/apt/sources.list.d/kubernetes.list
3. Agregue contenido al archivo anterior
deb http://mirrors.ustc.edu.cn/kubernetes/apt kubernetes-xenial main
O usar
echo "deb https://mirrors.aliyun.com/kubernetes/apt/ kubernetes-xenial main" | sudo tee -a /etc/apt/sources.list.d/kubernetes.list
4. Actualiza la fuente del sistema operativo
sudo apt update
Produce un error de autenticación de firma
en Las siguientes firmas no se pudieron verificar
porque el público en La clave no ES el disponible: NO_PUBKEY
6A030B21BA07F4FB
5. Recuerde los últimos 8 dígitos de NO_PUBKEY anteriores, agregue la clave de autenticación y las claves van seguidas de los últimos 8 dígitos de NO_PUBKEY (BA07F4FB)
gpg --keyserver keyserver.ubuntu.com --recv-keys BA07F4FB
6. Ingrese el comando, OK significa éxito, preste atención a los últimos 8 bits de NO_PUBKEY
gpg --export --armor BA07F4FB | sudo apt-key add -
7. Actualice de nuevo la fuente de descarga del sistema.
sudo apt update
8. Deshabilite el firewall
sudo ufw disable
9. Cierre la partición de intercambio
(1) Cerrar
sudo swapoff -a
(2) Modifique el archivo de configuración y ciérrelo permanentemente
sudo sed -i 's/.*swap.*/#&/' /etc/fstab
10. Prohibir selinux
(1) Instalar comandos para manipular selinux
sudo apt install -y selinux-utils
(2) Prohibir Selinux
setenforce 0
(3) Reinicie el sistema operativo (es posible que Alibaba Cloud deba reiniciar la instancia)
shutdown -r now
(4) Compruebe si selinux se ha cerrado
sudo getenforce
11. Verifique si la partición de intercambio está cerrada
free -m
11. Instalar kubenetes
sudo apt-get install -y kubelet=1.18.5-00 kubeadm=1.18.5-00 kubectl=1.18.5-00 kubernetes-cni=0.8.6-00
12. Configure el inicio automático después del arranque
sudo systemctl enable kubelet && systemctl start kubelet
13. Reiniciar (Alibaba Cloud reinicia la instancia)
sudo shutdown -r now
14. Verifique la instalación e intente usar el comando kubectl
kubectl get nodes
Solicitará la conexión al servidor localhost: 8080 fue rechazado: ¿especificó el host o puerto correcto? (Lo que indica una instalación exitosa)
15. Ver la versión actual de kubernetes
kubectl version
Tres, la inicialización del nodo maestro.
1. Muestre el archivo de inicialización predeterminado de kubeadm, imprímalo y escríbalo en el archivo kubeadm-config.conf.
kubeadm config print init-defaults ClusterConfiguration> kubeadm-config.conf
2. Modifique el archivo kubeadm-config.conf
advertiseAddress 改为本主节点地址(192.168.x.x)
imageRepository 修改镜像源(registry.aliyuncs.com/google_containers)
kubernetesVersion修改为对应版本
添加子网网络
networking:
dnsDomain: cluster.local
podSubnet: 10.244.0.0/16
serviceSubnet: 10.96.0.0/12
scheduler: {
}
Aquí 10.244.0.0/16 y 10.96.0.0/12 son las redes de subred de pods y servicios en k8s respectivamente. Es mejor usar esta dirección, y es necesario usar la red de franela subsiguiente.
3. Compruebe qué archivos de imagen se deben extraer
kubeadm config images list --config kubeadm-config.conf
4. Tira de la imagen
kubeadm config images pull --config ./kubeadm-config.conf
Aquí puede tirar del espejo doméstico y cambiarle el nombre
5. Inicializar y comenzar
sudo kubeadm init --config ./kubeadm-config.conf
6. Guarde el contenido de salida, escríbalo en el archivo y utilícelo para unirse al nodo.
Your Kubernetes master has initialized successfully!
To start using your cluster, you need to run the
following as a regular user:
mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config
You should now deploy a pod network to the cluster.
Run "kubectl apply -f [podnetwork].yaml" with one of
the options listed at:
https://kubernetes.io/docs/concepts/clusteradministration/addons/
You can now join any number of machines by running
the following on each node
as root:
kubeadm join 192.168.x.x:6443 --token
xxxxxx.xxxxxxxxxxxxxx --discovery-token-ca-certhash
sha256:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
7. Copie el archivo admin.conf y cambie el propietario.
mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config
8. Verificación
kubectl get nodes
En este momento NotReady
9, descarga franela
wget https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.yml
No se puede descargar la copia directamente
---
apiVersion: policy/v1beta1
kind: PodSecurityPolicy
metadata:
name: psp.flannel.unprivileged
annotations:
seccomp.security.alpha.kubernetes.io/allowedProfileNames: docker/default
seccomp.security.alpha.kubernetes.io/defaultProfileName: docker/default
apparmor.security.beta.kubernetes.io/allowedProfileNames: runtime/default
apparmor.security.beta.kubernetes.io/defaultProfileName: runtime/default
spec:
privileged: false
volumes:
- configMap
- secret
- emptyDir
- hostPath
allowedHostPaths:
- pathPrefix: "/etc/cni/net.d"
- pathPrefix: "/etc/kube-flannel"
- pathPrefix: "/run/flannel"
readOnlyRootFilesystem: false
# Users and groups
runAsUser:
rule: RunAsAny
supplementalGroups:
rule: RunAsAny
fsGroup:
rule: RunAsAny
# Privilege Escalation
allowPrivilegeEscalation: false
defaultAllowPrivilegeEscalation: false
# Capabilities
allowedCapabilities: ['NET_ADMIN', 'NET_RAW']
defaultAddCapabilities: []
requiredDropCapabilities: []
# Host namespaces
hostPID: false
hostIPC: false
hostNetwork: true
hostPorts:
- min: 0
max: 65535
# SELinux
seLinux:
# SELinux is unused in CaaSP
rule: 'RunAsAny'
---
kind: ClusterRole
apiVersion: rbac.authorization.k8s.io/v1beta1
metadata:
name: flannel
rules:
- apiGroups: ['extensions']
resources: ['podsecuritypolicies']
verbs: ['use']
resourceNames: ['psp.flannel.unprivileged']
- apiGroups:
- ""
resources:
- pods
verbs:
- get
- apiGroups:
- ""
resources:
- nodes
verbs:
- list
- watch
- apiGroups:
- ""
resources:
- nodes/status
verbs:
- patch
---
kind: ClusterRoleBinding
apiVersion: rbac.authorization.k8s.io/v1beta1
metadata:
name: flannel
roleRef:
apiGroup: rbac.authorization.k8s.io
kind: ClusterRole
name: flannel
subjects:
- kind: ServiceAccount
name: flannel
namespace: kube-system
---
apiVersion: v1
kind: ServiceAccount
metadata:
name: flannel
namespace: kube-system
---
kind: ConfigMap
apiVersion: v1
metadata:
name: kube-flannel-cfg
namespace: kube-system
labels:
tier: node
app: flannel
data:
cni-conf.json: |
{
"name": "cbr0",
"cniVersion": "0.3.1",
"plugins": [
{
"type": "flannel",
"delegate": {
"hairpinMode": true,
"isDefaultGateway": true
}
},
{
"type": "portmap",
"capabilities": {
"portMappings": true
}
}
]
}
net-conf.json: |
{
"Network": "10.244.0.0/16",
"Backend": {
"Type": "vxlan"
}
}
---
apiVersion: apps/v1
kind: DaemonSet
metadata:
name: kube-flannel-ds
namespace: kube-system
labels:
tier: node
app: flannel
spec:
selector:
matchLabels:
app: flannel
template:
metadata:
labels:
tier: node
app: flannel
spec:
affinity:
nodeAffinity:
requiredDuringSchedulingIgnoredDuringExecution:
nodeSelectorTerms:
- matchExpressions:
- key: kubernetes.io/os
operator: In
values:
- linux
hostNetwork: true
priorityClassName: system-node-critical
tolerations:
- operator: Exists
effect: NoSchedule
serviceAccountName: flannel
initContainers:
- name: install-cni
image: quay.io/coreos/flannel:v0.13.0-rc2
command:
- cp
args:
- -f
- /etc/kube-flannel/cni-conf.json
- /etc/cni/net.d/10-flannel.conflist
volumeMounts:
- name: cni
mountPath: /etc/cni/net.d
- name: flannel-cfg
mountPath: /etc/kube-flannel/
containers:
- name: kube-flannel
image: quay.io/coreos/flannel:v0.13.0-rc2
command:
- /opt/bin/flanneld
args:
- --ip-masq
- --kube-subnet-mgr
resources:
requests:
cpu: "100m"
memory: "50Mi"
limits:
cpu: "100m"
memory: "50Mi"
securityContext:
privileged: false
capabilities:
add: ["NET_ADMIN", "NET_RAW"]
env:
- name: POD_NAME
valueFrom:
fieldRef:
fieldPath: metadata.name
- name: POD_NAMESPACE
valueFrom:
fieldRef:
fieldPath: metadata.namespace
volumeMounts:
- name: run
mountPath: /run/flannel
- name: flannel-cfg
mountPath: /etc/kube-flannel/
volumes:
- name: run
hostPath:
path: /run/flannel
- name: cni
hostPath:
path: /etc/cni/net.d
- name: flannel-cfg
configMap:
name: kube-flannel-cfg
10. Edite este archivo para asegurarse de que la red de franela sea
correcta y averigüe si el contenido de la etiqueta net-conf.json es correcto.
net-conf.json: |
{
"Network": "10.244.0.0/16",
"Backend": {
"Type": "vxlan"
}
Este "10.244.0.0/16" y la dirección de podsubnet en ./kubeadm-config.conf
deben ser coherentes.
11. Aplicar el archivo de configuración de franela actual
kubectl apply -f kube-flannel.yml
12. Configure el inicio automático en el arranque e inicie kubelet.
sudo systemctl enable kubelet
sudo systemctl start kubelet
En este momento, kubectl get nodos nuevamente mostrará el nodo maestro Listo
Cuarto, el nodo del nodo (inicialización) se une al clúster k8s existente
1. Envíe el archivo /etc/kubernetes/admin.conf del nodo maestro al host del nodo actual
scp /etc/kubernetes/admin.conf 节点1用户名@192.168.x.x:/home/xxx
2. Cree un entorno de archivo de configuración de kube (el admin.conf aquí se pasa del maestro)
mkdir -p $HOME/.kube
sudo cp -i $HOME/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config
3. Únase al grupo
Aquí está el comando kubeadm join, que es el último resultado del comando cuando se inicializó el nodo maestro.
sudo kubeadm join 192.168.x.x:6443 --token xxxxxxxxxxxxxxx --discovery-token-ca-cert-hash sha256:xxxxxxxxxxxxxxxxxxxxxx
Tenga en cuenta que el hash utilizado aquí debe ser el código hash generado después de que el host maestro kubeadm init tenga éxito.
P.ej:
kubeadm join 192.168.64.131:6443 --token xxxxx.xxxxxxxxxx --discovery-token-ca-cert-hash sha256:xxxxxxxxxxxxxxxxxxxxxxxxxxxx
El token es válido por 24 horas. Si el maestro necesita regenerar el token y el código hash durante más de 24 horas, también se puede generar de forma indefinida.
-Generar token
kubeadm token create
Catalogado como:
[kubeadm] WARNING: starting in 1.8, tokens expire after 24 hours by default (if you require a non-expiring token use --ttl 0)
xxxxxx.xxxxxxxxxxxx
-Generar un código hash (el valor hash generalmente no cambia, el generado es el mismo que antes)
openssl x509 -pubkey -in /etc/kubernetes/pki/ca.crt | openssl rsa -pubin -outform der 2>/dev/null | openssl dgst -sha256 -hex | sed 's/^.* //'
Catalogado como:
0fd95a9bc67a7bf0ef42da968a0d55d92e52898ec37asdfasfdadfa
Ver token
kubeadm token list
O use el siguiente comando para regenerar y generar token
kubeadm token create --print-join-command
4. Si el nombre de host es el mismo, se informará un error, modifique el nombre de host, archivo / etc / hostname
5. Puede encontrar los siguientes errores, elimine /etc/kubernetes/pki/ca.crt y luego únase a master
[ERROR FileAvailable--etc-kubernetes-pki-ca.crt]: /etc/kubernetes/pki/ca.crt already exists
rm /etc/kubernetes/pki/ca.crt
6. El host del nodo utiliza la red de franela
(1) para enviar kube-flannel.yml en el nodo principal al host del nodo actual
sudo scp kube-flannel.yml 节点1用户名@节点1ip:/home/xxx
(2) El nodo host habilita la red de franela
kubectl apply -f kube-flannel.yml
Cinco, desalojo manual del módulo (módulo creado por el programador de implementación)
(1) Configure el nodo donde se encuentra el pod en el estado no programable,
conduzca el Pod en el nodo del nodo (primero configure el nodo en el estado de cordón no programable y luego expulse el Pod)
kubectl drain <node name>
(2) Elimine el pod en el nodo (el pod se volverá a crear mediante la implementación en otros nodos en este momento, si no hay ningún nodo disponible, el pod estará en estado Pendiente)
kubectl delete pod <pod name>
(3) Eliminar nodo
kubectl delete node <node name>
-Restaurar el nodo a un estado programable
kubectl uncordon <node name>
El pod en estado pendiente se programará en el nodo en este momento
Seis, kubectl crea un programador de implementación y operaciones básicas de kubectl
1. Crea un archivo yaml
apiVersion: apps/v1
kind: Deployment
metadata:
name: mydeployment
labels:
app: myapp
spec:
replicas: 1
selector:
matchLabels:
app: app
template:
metadata:
labels:
app: app
spec:
hostNetwork: true
dnsPolicy: ClusterFirstWithHostNet
containers:
- name: app1
image: myapp:v1
imagePullPolicy: IfNotPresent
ports:
- containerPort: 8880
- name: app2
image: myapp:v2
imagePullPolicy: IfNotPresent
ports:
- containerPort: 8881
réplicas: 1 El número de réplicas de pod que se espera mantener.
En este caso, hostNetwork: true se utiliza para que el pod utilice la red del nodo. En este momento, el nodo no puede crear una copia del pod del valor esperado (conflicto de puerto).
image: la imagen y la versión utilizada por myapp: v2.
imagePullPolicy: IfNotPresent indica que si el nodo donde está ubicado el pod actual, use la duplicación local, si no, obtenga
puertos de almacenes remotos :
-containerPort: puerto 8880 expuesto por el contenedor, porque se usa hostNetwork: true, esta configuración es la misma .
2. Use el archivo yaml para crear un programador de implementación
kubectl apply -f xxxx.yaml --record
3. Ver el nodo del nodo
kubectl get node -o wide
4. Ver todos los grupos
kubectl get pod -o wide
5. Ver el grupo de anuncios especificado
kubectl get pod <pod name>
6. Genere información de POD en formato JSON
kubectl get pod <pod name> --output json
7. Salida de información de POD en formato yaml
kubectl get pod <pod name> --output yaml
8. Eliminar pod
kubectl delete pod <pod name>
Los pods administrados por el programador de eliminación serán creados nuevamente por el programador para mantener el número deseado de pods.
9. Ver el programador de implementación
kubectl get deploy <deployment name> -o wide
10. Elimina el programador de implementación.
kubectl delete deploy <deployment name>
En este momento, todos los pods administrados por el programador saldrán uno tras otro.
11. Ver el nodo del nodo
kubectl get node -o wide
12. Eliminar el nodo nodo
kubectl delete node <node name>
Siete, actualización continua de implementación
1. Actualización de la aplicación (modificar la imagen del contenedor)
kubectl set image deployment <deployment name> <containers name>=<image name>:<tags>
2. Verifique el estado de la actualización
kubectl rollout status deployment <deployment name>
3. Ver versión histórica
kubectl rollout history deployment <deployment name>
4. Regrese a la versión anterior
kubectl rollout undo deployment <deployment name>
5. Regrese a la versión especificada
kubectl rollout undo deployment <deployment name> --to-revision=历史版本号
6. Escalado elástico (expansión en línea)
kubectl scale deployment <deployment name> --replicas=期望副本数量
8. Conéctese a Alibaba Cloud Private Warehouse
1. Ver secreto
kubectl get secret [-n 名称空间默认default]
Solo hay uno por defecto
root@master:~# kubectl get secret
NAME TYPE DATA AGE
default-token-cx7df kubernetes.io/service-account-token 3 17d
2. Crea un secreto
kubectl create secret docker-registry ali-secret --namespace=default --docker-server=registry.cn-beijing.aliyuncs.com --docker-username=username --docker-password=password --docker-email=dockerEmail
参数说明：
ali-secret：secret名字
--docker-serve：私有仓库地址
--docker-username：私有仓库登录用户名
--docker-password：私有仓库登录密码
--docker-email：登录邮箱（可选）
--namespace:指定命名空间 （可选）
3. Marque uno más
root@master:~# kubectl get secret
NAME TYPE DATA AGE
ali-secret kubernetes.io/dockerconfigjson 1 3m12s
default-token-cx7df kubernetes.io/service-account-token 3 17d
4. Ver en formato yaml
kubectl get secret ali-secret -n default -o yaml
5. Uso de implementación
apiVersion: apps/v1
kind: Deployment
metadata:
name: mydeployment
labels:
app: myapp
spec:
replicas: 1
selector:
matchLabels:
app: app
template:
metadata:
labels:
app: app
spec:
imagePullSecrets:
- name: ali-secret （使用刚才创建的secret）
hostNetwork: true
dnsPolicy: ClusterFirstWithHostNet
containers:
- name: app1
image: registry.cn-beijing.aliyuncs.com/xxx/xxx:[镜像版本号]
imagePullPolicy: IfNotPresent
ports:
- containerPort: 8880
注意
指定使用的secret
imagePullSecrets:
- name: ali-secret （使用刚才创建的secret）
指定使用镜像的全名称:版本号
image: registry.cn-beijing.aliyuncs.com/xxx/xxx:[镜像版本号]
6. Ingrese al contenedor
kubectl exec <pod名> -c <容器名> -it /bin/bash
7. Ver detalles del grupo
kubectl describe pod [pod名]