k8s 部署 ruoyi 前后端分离项目

本文视频版: https://www.bilibili.com/video/BV17ugkePEeN

参考

https://blog.csdn.net/qq_50247813/article/details/136934090

https://gitee.com/nasaa/RuoYi-Vue-cloud

https://www.itsgeekhead.com/tuts/kubernetes-129-ubuntu-22-04-3/

https://kubernetes.io/docs/setup/production-environment/tools/kubeadm/install-kubeadm/

https://github.com/Joxit/docker-registry-ui/issues/140

前置条件

三台虚拟机：

hostname	ip	作用
node80	192.168.10.80	k8s 节点，控制平面
node81	192.168.10.81	k8s 节点
node82	192.168.10.82	k8s 节点
node84	192.168.10.84	镜像仓库

三台虚拟机都配置了主机名和 ip 的映射，windows 也配置了主机名到 ip 的映射。

三台虚拟机都能访问互联网，最好能访问国外镜像仓库。

安装 k8s

下面这些步骤需要在每一个 k8s 节点上执行。

确保 k8s 在启动时加载内核模块 overlay 和 br_netfilter两个内核模块：

printf "overlay\nbr_netfilter\n" >> /etc/modules-load.d/containerd.conf

立即加载 overlay 、br_netfilter 内核模块：

modprobe overlay
modprobe br_netfilter

配置 k8s 的网络：

printf "net.bridge.bridge-nf-call-iptables = 1\nnet.ipv4.ip_forward = 1\nnet.bridge.bridge-nf-call-ip6tables = 1\n" >> /etc/sysctl.d/99-kubernetes-cri.conf

重新加载配置：

sysctl --system

安装 containerd：

wget https://github.com/containerd/containerd/releases/download/v1.7.13/containerd-1.7.13-linux-amd64.tar.gz -P /opt/software/
tar Cxzvf /usr/local /opt/software/containerd-1.7.13-linux-amd64.tar.gz
wget https://raw.githubusercontent.com/containerd/containerd/main/containerd.service -P /etc/systemd/system/
systemctl daemon-reload
systemctl enable --now containerd

安装 runc：

wget https://github.com/opencontainers/runc/releases/download/v1.1.12/runc.amd64 -P /opt/software/
install -m 755 /opt/software/runc.amd64 /usr/local/sbin/runc

安装 cni 网络插件：

wget https://github.com/containernetworking/plugins/releases/download/v1.4.0/cni-plugins-linux-amd64-v1.4.0.tgz -P /opt/software/
mkdir -p /opt/cni/bin
tar Cxzvf /opt/cni/bin /opt/software/cni-plugins-linux-amd64-v1.4.0.tgz

修改 containerd 的配置并重启 containerd：

mkdir -p /etc/containerd
containerd config default | tee /etc/containerd/config.toml
vim /etc/containerd/config.toml
# 修改 SystemdCgroup 配置项的值为 truesystemctl restart containerd

关闭 swap：

vim /etc/fstab

注释掉最后一行：

更新 apt-get 并信任 k8s 官网链接：

apt-get update
apt-get install -y apt-transport-https ca-certificates curl gpgmkdir -p -m 755 /etc/apt/keyrings
curl -fsSL https://pkgs.k8s.io/core:/stable:/v1.29/deb/Release.key | sudo gpg --dearmor -o /etc/apt/keyrings/kubernetes-apt-keyring.gpg
echo 'deb [signed-by=/etc/apt/keyrings/kubernetes-apt-keyring.gpg] https://pkgs.k8s.io/core:/stable:/v1.29/deb/ /' | sudo tee /etc/apt/sources.list.d/kubernetes.listapt-get update

重启：

reboot

下载 k8s 软件包：

apt-get install -y kubelet=1.29.1-1.1 kubeadm=1.29.1-1.1 kubectl=1.29.1-1.1
apt-mark hold kubelet kubeadm kubectl

apt-mark hold kubelet kubeadm kubectl 命令的作用是将 kubelet、kubeadm 和 kubectl 这三个软件包标记为“保留”状态。这意味着这些软件包不会被系统自动升级或删除

检查 swap 是否关闭，确保 swap 是 0：

free -m

下面这些步骤仅仅需要在控制平面节点执行：

# 这个命令会比较耗时，这里的 node80 需要改为你自己的 k8s master 的 hostname，这里需要网络状况良好，能畅通的访问国外仓库，否则，容易发生拉取镜像失败，建议执行前切换为网速较好的节点
kubeadm init --pod-network-cidr 10.10.0.0/16 --kubernetes-version 1.29.1 --node-name node80# 这种切换方式重启后会失效，可以向 ~/.bashrc 文件末尾添加 export KUBECONFIG=/etc/kubernetes/admin.conf 后，再使用 source ~/.bashrc 使配置永久生效
export KUBECONFIG=/etc/kubernetes/admin.conf# add Calico 3.27.2 CNI
kubectl create -f https://raw.githubusercontent.com/projectcalico/calico/v3.27.2/manifests/tigera-operator.yaml
wget https://raw.githubusercontent.com/projectcalico/calico/v3.27.2/manifests/custom-resources.yaml
# 将 CIDR 配置为 10.10.0.0/16
vim custom-resources.yaml
kubectl apply -f custom-resources.yaml# 获取 worker 节点加入到集群的命令
kubeadm token create --print-join-command

在 worker 节点执行上面获取到的将 worker 节点加入到集群的命令将当前节点加入到 k8s 集群中：

kubeadm join 192.168.10.80:6443 --token pecvqm.rlxcsywbvm2resvv \--discovery-token-ca-cert-hash sha256:fac6cb7a265dc30d7560517dc64debaf933592215a58a8912453f6a56bde7701

–pod-network-cidr 明确了 Kubernetes 集群中 Pod 网络的 IP 地址范围

安装镜像仓库 registry

安装 htpasswd 工具：

sudo apt-get update
sudo apt-get install apache2-utils

创建挂载容器的目录以及密码文件：

mkdir -p /docker/volume/registry/auth/
htpasswd -Bc /docker/volume/registry/auth/htpasswd root
# 输入 root 的密码

创建 registry 容器挂载数据的目录：

mkdir -p /docker/volume/registry/data

创建 registry 挂载配置文件的目录，并创建配置文件：

mkdir -p /docker/volume/registry/conf

vim /docker/volume/registry/conf/config.yml

version: 0.1
log:level: debugfields:service: registryenvironment: production
storage:filesystem:rootdirectory: /var/lib/registry
http:addr: :5000headers:Access-Control-Allow-Origin: ['http://node84:8080','http://192.168.10.84']Access-Control-Allow-Methods: ['HEAD', GET', 'OPTIONS', 'DELETE', 'POST', 'PUT']Access-Control-Allow-Headers: ['Authorization','Accept']http2:disabled: false
auth:htpasswd:realm: basic-realmpath: /auth/htpasswd

创建 docker 网络：

docker network create registry-net

启动 registry 容器：

docker run -d \--name registry \--network registry-net \-v /docker/volume/registry/auth:/auth \-v /docker/volume/registry/data:/var/lib/registry \-v /docker/volume/registry/conf/config.yml:/etc/docker/registry/config.yml \-e REGISTRY_AUTH=htpasswd \-e REGISTRY_AUTH_HTPASSWD_REALM="Registry Realm" \-e REGISTRY_AUTH_HTPASSWD_PATH=/auth/htpasswd \-e REGISTRY_HTTP_SECRET=secretkey \-p 5000:5000 \registry:2

修改 containerd 的配置（所有 k8s 节点都需要修改），配置 containerd 以允许从私有镜像仓库 node84:5000 拉取和推送镜像，并且跳过证书验证：

mkdir -p /etc/containerd/certs.d/node84:5000tee /etc/containerd/certs.d/node84:5000/hosts.toml << 'EOF'
server = "http://node84:5000"[host."http://node84:5000"]capabilities = ["pull", "resolve", "push"]skip_verify = true
EOFsystemctl restart containerd.service

添加配置（所有 k8s 节点都需要修改）告诉 containerd，当它需要拉取镜像时，首先从自定义的镜像仓库 http://node84:5000 获取镜像，这样才能拉取到我们自己打到 registry 私有镜像仓库的镜像：

如果不喜欢用 nano，也可以使用 vim 编辑文件

[plugins."io.containerd.grpc.v1.cri".registry.mirrors][plugins."io.containerd.grpc.v1.cri".registry.mirrors."node84:5000"]endpoint = ["http://node84:5000"]

注意：上面的 node84 是 registry 的地址，如果 registry 地址不是 node84，两个 node84 都需要更改为你的 registry 的地址，所有 k8s 机器都需要修改

sudo systemctl restart containerd

因为我们需要将 docker 上的镜像（第四台机器，node84）推送到 registry 中，所以，也需要修改 docker 的配置（第四台机器，node84），将 node84 添加到 docker 的安全镜像仓库名单中，避免使用 docker 推送镜像到 registry 中报错，将 "insecure-registries": ["192.168.56.10:5000"]' 加入到 /etc/docker/daemon.json 中，再使用 systemctl restart docker 重启 Docker 就可以了。

{"insecure-registries": ["node84:5000"]
}

安装 registry 可视化工具

启动一个 registry-browser 容器并连接到自定义网络：

docker run -d \--name registry-browser \--network registry-net \-e REGISTRY_TITLE="Docker Registry Browser" \-e NGINX_PROXY_PASS_URL="http://registry:5000" \-e REGISTRY_AUTH="true" \-e REGISTRY_AUTH_USER="root" \-e REGISTRY_AUTH_PASSWORD="123456" \-p 8080:80 \joxit/docker-registry-ui:latest

比较老的版本中使用 -e REGISTRY_URL=“http://registry:5000” \ 配置 registry 的地址，如果新版本中使用这个配置，在前端会出现 An error occured: Check your connection and your registry must have Access-Control-Allow-Origin header set to http://node84:8080这个异常，需要使用 NGINX_PROXY_PASS_URL 这个配置

访问主机的 8080 端口即可看到 registry 中的镜像。

部署 ruoyi 前后端分离项目

制作后端镜像

编写 Dockerfile 文件：

# 使用官方的 OpenJDK 8 镜像作为基础镜像
FROM openjdk:8-jdk-alpine
# 创建存放上传文件的目录
RUN mkdir -p /opt/project/ruoyi/ruoyi-backend/upload-file-path
# 创建存放日志的目录
RUN mkdir -p /opt/project/ruoyi/ruoyi-backend/logs
# 安装字体文件
RUN mkdir -p /etc/apk/
RUN touch /etc/apk/repositories
RUN echo -e 'https://mirrors.aliyun.com/alpine/v3.6/main/\nhttps://mirrors.aliyun.com/alpine/v3.6/community/' > /etc/apk/repositories
RUN set -xe && apk --no-cache add ttf-dejavu fontconfig
# 设置工作目录
WORKDIR /opt/project/ruoyi/ruoyi-backend
# 将构建好的 JAR 文件复制到容器中
COPY ./ruoyi-admin/target/ruoyi-admin.jar ruoyi-admin.jar
# 暴露应用程序端口
EXPOSE 8080
# 启动应用程序
CMD ["nohup","java","-jar","/opt/project/ruoyi/ruoyi-backend/ruoyi-admin.jar", ">", "/opt/project/ruoyi/ruoyi-backend/logs/nohup.log", "&"]

直接用 idea 连接到我们虚拟机中的 Docker 上，在 idea 中点击 Dockerfile 中的绿色箭头将后端打成镜像。

在虚拟机中查看镜像是否好了：

docker images

将打好的后端镜像推送到 registry 中：

#推送后端镜像
#修改镜像tag
docker tag ruoyi-backend:1.0 node84:5000/ruoyi-backend:1.0# 因为 registry 设置了用户名和密码，所以需要先登录才能推送镜像
docker login -u root -p 123456 node84:5000#推送到私有镜像仓库中
docker push node84:5000/ruoyi-backend:1.0

制作前端镜像

编写前端的 Dockerfile：

# 使用 Nginx 作为基础镜像
FROM nginx:1.12.2
# 将 nginx.conf 拷贝到容器中
COPY nginx.conf /etc/nginx/nginx.conf
# 创建存放前端编译后代码的目录
RUN mkdir -p /opt/project/ruoyi/ruoyi-front-code
# 将构建好的应用拷贝到 Nginx 的默认 web 目录
COPY dist /opt/project/ruoyi/ruoyi-front-code
# Expose 端口
EXPOSE 80
# 启动 Nginx 服务器
CMD ["nginx", "-g", "daemon off;"]

直接用 webstorm 连接到我们虚拟机中的 Docker 上，在 webstorm 中点击 Dockerfile 中的绿色箭头将后端打成镜像。

在虚拟机中查看镜像是否好了：

docker images

将打好的前端镜像推送到 registry 中：

#推送前端镜像
#修改镜像tag
docker tag ruoyi-frontend:1.0 node84:5000/ruoyi-frontend:1.0# 因为 registry 设置了用户名和密码，所以需要先登录才能推送镜像
docker login -u root -p 123456 node84:5000#推送到私有镜像仓库中
docker push node84:5000/ruoyi-frontend:1.0

k8s 部署后端

将后端初始化的两个 sql 文件创建为 configmap

将 ruoyi 后端的两个初始化 sql 文件放入 /opt/ruoyi/sql 中：

mkdir -p /opt/ruoyi/sql

切换成 k8s 的管理员：

export KUBECONFIG=/etc/kubernetes/admin.conf

这种切换方式重启后会失效，可以向 ~/.bashrc 文件末尾添加 export KUBECONFIG=/etc/kubernetes/admin.conf 后，再使用 source ~/.bashrc 使配置永久生效

使用如下命令检查是否切换成功：

kubectl cluster-info

创建一个为我们当前机器分配在 default 空间下创建 configmap 权限的配置文件：

apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:namespace: defaultname: configmap-creator
rules:
- apiGroups: [""]resources: ["configmaps"]verbs: ["create", "update", "patch", "delete"]---
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:name: configmap-creator-bindingnamespace: default
subjects:
- kind: Username: system:node:node80apiGroup: rbac.authorization.k8s.io
roleRef:kind: Rolename: configmap-creatorapiGroup: rbac.authorization.k8s.io

使这个配置文件生效：

kubectl apply -f role-config.yaml

当前节点就有在 default 空间下创建 configmap 的权限了。

根据 ruoyi 后端的初始化 SQL 文件创建 configMap：

注意：sql 文件头部要加上：use ry-vue; SET NAMES utf8;

kubectl create configmap ruoyi-init-sql-config-map --from-file=/opt/ruoyi/sql
# 查看这个 configmap 的详情
kubectl describe configmap/ruoyi-init-sql-config-map

将需要修改的后端配置创建为 configmap

后端的镜像中，application.yaml 配置文件中 MySQL 和 Redis 的地址都是写死的，需要我们根据要求创建在 k8s 中使用的 configMap。

拷贝一份 application.yaml 配置文件，将其中的 ip 地址改为对应 service 的服务名地址：

# 数据源配置
spring:redis:# 地址host: ruoyi-redis-service# 端口，默认为6379port: 6379# 数据库索引database: 0# 密码password: 123456# 连接超时时间timeout: 10slettuce:pool:# 连接池中的最小空闲连接min-idle: 0# 连接池中的最大空闲连接max-idle: 8# 连接池的最大数据库连接数max-active: 8# #连接池最大阻塞等待时间（使用负值表示没有限制）max-wait: -1msdatasource:type: com.alibaba.druid.pool.DruidDataSourcedriverClassName: com.mysql.cj.jdbc.Driverdruid:# 主库数据源master:url: jdbc:mysql://ruoyi-mysql-service:3306/ry-vue?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=false&serverTimezone=GMT%2B8&connectTimeout=1000&socketTimeout=30000&autoReconnect=true&failOverReadOnly=falseusername: rootpassword: 123456# 从库数据源slave:# 从数据源开关/默认关闭enabled: falseurl:username:password:# 初始连接数initialSize: 5# 最小连接池数量minIdle: 10# 最大连接池数量maxActive: 20# 配置获取连接等待超时的时间maxWait: 60000# 配置连接超时时间connectTimeout: 30000# 配置网络超时时间socketTimeout: 60000# 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒timeBetweenEvictionRunsMillis: 60000# 配置一个连接在池中最小生存的时间，单位是毫秒minEvictableIdleTimeMillis: 300000# 配置一个连接在池中最大生存的时间，单位是毫秒maxEvictableIdleTimeMillis: 900000# 配置检测连接是否有效validationQuery: SELECT 1 FROM DUALtestWhileIdle: truetestOnBorrow: falsetestOnReturn: falsewebStatFilter:enabled: truestatViewServlet:enabled: true# 设置白名单，不填则允许所有访问allow:url-pattern: /druid/*# 控制台管理用户名和密码login-username: ruoyilogin-password: 123456filter:stat:enabled: true# 慢SQL记录log-slow-sql: trueslow-sql-millis: 1000merge-sql: truewall:config:multi-statement-allow: true

根据这个配置文件生成 configMap：

kubectl create configmap ruoyi-admin-config --from-file=/opt/ruoyi/application-k8s.yaml
kubectl describe configmap/ruoyi-admin-config

将 redis 服务的配置 redis.conf 创建为 configmap

下载需要的 redis 对应版本，解压后拷贝 redis.conf 文件，修改配置文件中的如下部分：

# 注释掉 bind 127.0.0.1，bind 用于限制访问 Redis 的机器 ip,直接关掉
# bind 127.0.0.1# 修改 daemonize no 为 yes，让 Redis 可以后台启动
daemonize yes# 设置密码
requirepass 123456

根据这个 redis.conf 配置文件生成 configMap：

kubectl create configmap ruoyi-redis-config-map --from-file=/opt/ruoyi/redis.conf
kubectl describe configmap/ruoyi-redis-config-map

将 registry 的用户名和密码创建为 secret

创建一个 secret 用于存储我们的 registry 仓库的用户名和密码，在 k8s 资源编排 yaml 文件中，在 deployment 中使用 imagePullSecrets 字段就可以引用这个 Secret 对象，这样 Kubernetes 就可以在拉取镜像时使用这个 Secret 对象中的认证信息。

kubectl create secret registry-user-pwd-secret \--docker-server=http://node84:5000 \--docker-username=root \--docker-password=123456

部署后端服务

后端部署的 k8s 资源清单：

# 数据库
apiVersion: apps/v1
kind: Deployment
metadata:name: databasenamespace: default
spec:selector:matchLabels:app: databasetemplate:metadata:labels:app: databasespec:containers:- name: databaseimage: mysql:8.0env:- name: MYSQL_ROOT_PASSWORDvalue: "123456"- name: MYSQL_DATABASEvalue: "ry-vue"volumeMounts:- mountPath: /docker-entrypoint-initdb.dname: ruoyi-init-sqlresources:limits:memory: "512Mi"cpu: "500m"ports:- containerPort: 3306volumes:- name: ruoyi-init-sqlconfigMap:name: ruoyi-init-sql-config-mapimagePullSecrets:- name: registry-user-pwd-secret---
apiVersion: v1
kind: Service
metadata:name: ruoyi-mysql-servicenamespace: default
spec:selector:app: databaseports:- port: 3306targetPort: 3306---
# redis
apiVersion: apps/v1
kind: Deployment
metadata:name: redis
spec:selector:matchLabels:app: redistemplate:metadata:labels:app: redisspec:containers:- name: redisimage: redis:7.2.0resources:limits:memory: "512Mi"cpu: "500m"ports:- containerPort: 6379volumeMounts:- mountPath: /usr/local/etc/redis/redis.confname: ruoyi-redis-configvolumes:- name: ruoyi-redis-configconfigMap:name: ruoyi-redis-config-mapimagePullSecrets:- name: registry-user-pwd-secret---
apiVersion: v1
kind: Service
metadata:name: ruoyi-redis-servicenamespace: default
spec:selector:app: redisports:- port: 6379targetPort: 6379# ruoyi 后端
---
apiVersion: apps/v1
kind: Deployment
metadata:name: ruoyi-java
spec:replicas: 2selector:matchLabels:app: ruoyi-javatemplate:metadata:labels:app: ruoyi-javaspec:initContainers:- name: wait-for-mysqlimage: mysql:8.0env:- name: MYSQL_ROOT_PASSWORDvalue: "123456"command:- sh- -c- |set -emaxTries=10while [ "$$maxTries" -gt 0 ] \&& ! mysqladmin ping --connect-timeout=3 -s \-hruoyi-mysql-service -uroot -p$$MYSQL_ROOT_PASSWORDdo echo 'Waiting for MySQL to be available'sleep 5let maxTries--doneif [ "$$maxTries" -le 0 ]; thenecho >&2 'error: unable to contact MySQL after 10 tries'exit 1fi- name: wait-for-redisimage: redis:7.2.0env:- name: REDIS_PASSWORDvalue: "123456"command:- sh- -c- |set -emaxTries=10while [ "$$maxTries" -gt 0 ] \&& ! timeout 3 redis-cli -h ruoyi-redis-service -a $$REDIS_PASSWORD pingdo echo 'Waiting for Redis to be available'sleep 5let maxTries--doneif [ "$$maxTries" -le 0 ]; thenecho >&2 'error: unable to contact Redis after 10 tries'exit 1ficontainers:- name: ruoyi-javaimage: node84:5000/ruoyi-backend:1.0resources:limits:memory: "512Mi"cpu: "512m"imagePullPolicy: Alwaysports:- containerPort: 8080# /app/ruoyi/ 是 dockerfile 中拷贝 jar 包所到的目录# springboot 启动时，会从 jar 包所在的目录的 config 子目录中查找配置文件volumeMounts:- mountPath: /opt/project/ruoyi/ruoyi-backend/configname: config# 使用 application-k8s.yaml 作为配置文件args:["java", "-jar", "ruoyi-admin.jar", "--spring.profiles.active=k8s"]volumes:- name: configconfigMap:name: ruoyi-admin-configimagePullSecrets:- name: registry-user-pwd-secret
---
apiVersion: v1
kind: Service
metadata:name: ruoyi-backend-servicenamespace: default
spec:selector:app: ruoyi-javaports:- port: 8080targetPort: 8080

根据资源清单部署后端：

kubectl apply -f ruoyi-k8s-backend.yaml

k8s 部署前端

将前端的 nginx.conf 创建为 configmap

Nginx 的配置文件：

server {listen       80;server_name  localhost;charset utf-8;location / {# dockerfile中WORKDIR目录root   /opt/project/ruoyi/ruoyi-front-code;try_files $uri $uri/ /index.html;index  index.html index.htm;}location /prod-api/ {proxy_set_header Host $http_host;proxy_set_header X-Real-IP $remote_addr;proxy_set_header REMOTE-HOST $remote_addr;proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;# 后端 service 的 DNSproxy_pass http://ruoyi-backend-service.default:8080/;}error_page   500 502 503 504  /50x.html;location = /50x.html {root   html;}
}

根据 Nginx 配置文件创建 configMap：

kubectl create configmap ruoyi-ui-config --from-file=/opt/ruoyi/nginx.conf
kubectl describe configmap/ruoyi-ui-config

部署前端服务

前端部署的 k8s 资源清单：

apiVersion: apps/v1
kind: Deployment
metadata:name: ruoyi-nginx
spec:replicas: 1selector:matchLabels:app: ruoyi-nginxtemplate:metadata:labels:app: ruoyi-nginxspec:initContainers:- name: wait-for-ruoyi-backend-serviceimage: alpinecommand:- sh- -c- |apk add --no-cache curlecho "Starting to wait for ruoyi-backend-service..."until curl -s -f -m 3 http://ruoyi-backend-service:8080doecho "Waiting for ruoyi-backend-service...";sleep 5;doneecho "ruoyi-backend-service is available now."containers:- name: ruoyi-nginximage: node84:5000/ruoyi-frontend:1.0resources:limits:memory: "512Mi"cpu: "512m"imagePullPolicy: Alwaysports:- containerPort: 80volumeMounts:- mountPath: /etc/nginx/conf.dname: configvolumes:- name: configconfigMap:name: ruoyi-ui-configitems:- key: nginx.confpath: default.confimagePullSecrets:- name: registry-user-pwd-secret---
apiVersion: v1
kind: Service
metadata:name: ruoyi-fronted-servicenamespace: default
spec:type: NodePortselector:app: ruoyi-nginxports:- port: 80targetPort: 80nodePort: 30000

根据资源清单启动前端：

kubectl apply -f ruoyi-k8s-fronted.yaml

前端通过 nodePort 暴露出去了，访问任意 k8s 节点的 30000 端口即可访问前端。

遇到的问题

拉取镜像失败

只要出现这种情况：

ctr: failed to copy: httpReadSeeker: failed open: failed to do request: Get "https://production.cloudflare.docker.com/registry-v2/docker/registry/v2/blobs/sha256/52/52d2b7f179e32b4cbd579ee3c4958027988f9a8274850ab0c7c24661e3adaac5/data?verify=1719112771-ZRsD38JmAnzgLW0YPDJ4BVoEmvw%3D": dial tcp 162.220.12.226:443: connect: connection refused

就是网络不通，需要开代理。

可以使用如下命令测试拉取镜像是否能成功：

sudo ctr images pull docker.io/library/redis:7.2.0

可以配置 containerd 使用阿里云的镜像仓库加速：

vim /etc/containerd/config.toml

      [plugins."io.containerd.grpc.v1.cri".registry.mirrors][plugins."io.containerd.grpc.v1.cri".registry.mirrors."node63:5000"]endpoint = ["http://node63:5000"][plugins."io.containerd.grpc.v1.cri".registry.mirrors."docker.io"]endpoint = ["https://6zemac9k.mirror.aliyuncs.com"]

修改后重启 containerd：

sudo systemctl restart containerd

配置完后，拉取镜像的时候并没有从 aliyun 拉取，不知道为什么。

最后我还是选择了使用代理。

拉取前后端镜像失败

containerd 的配置 /etc/containerd/config.toml 中：

   [plugins."io.containerd.grpc.v1.cri".registry.mirrors][plugins."io.containerd.grpc.v1.cri".registry.mirrors."<font style="background-color:#FBDE28;">node63:5000</font>"]endpoint = ["http://node63:5000"][plugins."io.containerd.grpc.v1.cri".registry.mirrors."docker.io"]endpoint = ["https://6zemac9k.mirror.aliyuncs.com"]

registry.mirrors.“node63:5000” 之前因为忘了修改，应该要改成现在的 registry 的地址 node63:5000。