k8s部署Spring Cloud应用_kuboard怎么部署cloud项目

k8s案例

 

1. 项目打包成jar文件
2. 构建镜像
   • jdk
   • eureka
   • item
   • user
   • order
3. 把镜像传到所有服务器导入(真实生产做法是将镜像上传到私服镜像仓库，不需要一个一个上传到每台服务器)
4. 部署四个模块

下载并导入第18章代码

https://github.com/benwang6/spring-cloud-repo

只导入前5个项目

修改2,3,4,5项目的yml配置,添加相面配置,使用ip注册

eureka:
  instance:
    prefer-ip-address: true

按项目顺序执行:

• 右键 – run as – maven build…
• Goals: install
• 勾选 Skip Tests.

创建四个空文件夹,将2,3,4,5四个项目的jar文件复制到四个文件夹中:

• eureka
• item
• user
• order

构建镜像

将 centos:7 镜像导入服务器

复制centos7-docker-image.gz到服务器并导入

jdk镜像

新建文件夹 jdk, 复制jdk-8u212-linux-x64.tar.gz到jdk目录

在 jdk目录创建 Dockerfile 文件

cat <<EOF > Dockerfile
FROM centos:7
ADD jdk-8u212-linux-x64.tar.gz /opt/
ENV JAVA_HOME=/opt/jdk1.8.0_212 \
    PATH=$PATH:/opt/jdk1.8.0_212/bin:/usr/tomcat/bin
ENTRYPOINT bash
EOF

构建镜像

docker build -t centos7-jdk8:v1 .

eureka镜像

进入eureka目录,创建构建文件

cat <<EOF > Dockerfile
FROM centos7-jdk8:v1
COPY sp05-eureka-0.0.1-SNAPSHOT.jar /opt/
ENTRYPOINT ["java", "-jar", "/opt/sp05-eureka-0.0.1-SNAPSHOT.jar"]
CMD ["--spring.profiles.active=eureka1", "--server.port=2001"]
EOF

构建镜像

docker build -t sp-eureka:v1 .

item-service 镜像

进入item目录,创建构建文件

cat <<EOF > Dockerfile
FROM centos7-jdk8:v1
COPY sp02-itemservice-0.0.1-SNAPSHOT.jar /opt/
ENTRYPOINT ["java", "-jar", "/opt/sp02-itemservice-0.0.1-SNAPSHOT.jar"]
EOF

构建镜像

docker build -t sp-item:v1 .

user-service 镜像

进入user目录,创建构建文件

cat <<EOF > Dockerfile
FROM centos7-jdk8:v1
COPY sp03-userservice-0.0.1-SNAPSHOT.jar /opt/
ENTRYPOINT ["java", "-jar", "/opt/sp03-userservice-0.0.1-SNAPSHOT.jar"]
EOF

构建镜像

docker build -t sp-user:v1 .

order-service 镜像

进入docker目录,创建构建文件

cat <<EOF > Dockerfile
FROM centos7-jdk8:v1
COPY sp04-orderservice-0.0.1-SNAPSHOT.jar /opt/
ENTRYPOINT ["java", "-jar", "/opt/sp04-orderservice-0.0.1-SNAPSHOT.jar"]
EOF

构建镜像

docker build -t sp-order:v1 .

导出镜像,再导入其他服务器

docker save \
        centos7-jdk8:v1 \
        sp-eureka:v1 \
        sp-item:v1 \
        sp-user:v1 \
        sp-order:v1 \
        | gzip > img.gz
 
# 将文件复制到 192 和 193
scp img.gz 192.168.64.192:/root/
 
scp img.gz 192.168.64.193:/root/

# 在 192 和 193 执行导入 docker load -i img.gz
ssh 192.168.64.192 'docker load -i /root/img.gz'
 
ssh 192.168.64.193 'docker load -i /root/img.gz'
 
# 查看 192 和 193 的镜像列表
ssh 192.168.64.192 'docker images'
 
ssh 192.168.64.193 'docker images'

部署

eureka

由于eureka集群相互注册
    http://eureka1:2001/eureka
    http://eureka2:2002/eureka
可以通过创建2个service的服务名分为eureka1、eureka2
内网就可以通过http://eureka1、http://eureka2访问了。
而外部可以通过对外暴露端口30123、30124
http://192.168.111.30123
http://192.168.111.30124

用rs部署容器, 先创建rs部署描述文件

cat <<EOF > eureka1-rs.yml
apiVersion: apps/v1              # RS 是 apps/v1中提供的资源类型
kind: ReplicaSet                 # 资源类型
metadata:
  name: eureka1                    # RS 命名为 eureka1
spec:
  replicas: 1                    # pod 副本数量
  selector:
    matchLabels:                 # 使用 label 选择器
      app: eureka1                 # 选取标签是 "app=eureka1" 的pod
  template:
    metadata:
      labels:
        app: eureka1               # 为创建的pod添加标签 "app=eureka1"
    spec:
      containers:
      - name: eureka1             # 容器名
        image: sp-eureka:v1       # 镜像
        ports:
        - containerPort: 2001    # 容器暴露的端口
          protocol: TCP
EOF

cat <<EOF > eureka2-rs.yml
apiVersion: apps/v1              # RS 是 apps/v1中提供的资源类型
kind: ReplicaSet                 # 资源类型
metadata:
  name: eureka2                    # RS 命名为 eureka2
spec:
  replicas: 1                    # pod 副本数量
  selector:
    matchLabels:                 # 使用 label 选择器
      app: eureka2                 # 选取标签是 "app=eureka2" 的pod
  template:
    metadata:
      labels:
        app: eureka2               # 为创建的pod添加标签 "app=eureka2"
    spec:
      containers:
      - name: eureka2             # 容器名
        image: sp-eureka:v1       # 镜像
        args: ["--spring.profiles.active=eureka2", "--server.port=2002"]
        ports:
        - containerPort: 2002    # 容器暴露的端口
          protocol: TCP
EOF

部署rs, rs会自动创建容器,启动eureka服务器

k create -f eureka1-rs.yml
k create -f eureka2-rs.yml

部署 service, 对外暴露eureka访问

这里我们只暴露一个eureka服务器进行测试

cat <<EOF > eureka1-svc.yml
apiVersion: v1
kind: Service
metadata:
  name: eureka1
spec:
  type: NodePort           # 在每个节点上开放访问端口
  ports:
  - port: 2001               # 集群内部访问该服务的端口
    targetPort: 2001       # 容器的端口
    nodePort: 30123        # 外部访问端口
  selector:
    app: eureka1
EOF

cat <<EOF > eureka2-svc.yml
apiVersion: v1
kind: Service
metadata:
  name: eureka2
spec:
  type: NodePort           # 在每个节点上开放访问端口
  ports:
  - port: 2002              # 集群内部访问该服务的端口
    targetPort: 2002       # 容器的端口
    nodePort: 30124        # 外部访问端口
  selector:
    app: eureka2
EOF

执行部署

k create -f eureka1-svc.yml
k create -f eureka2-svc.yml

部署后访问测试:
http://192.168.64.191:30123/
http://192.168.64.191:30124/

item-service

cat <<EOF > item-rs.yml
apiVersion: apps/v1              # RS 是 apps/v1中提供的资源类型
kind: ReplicaSet                 # 资源类型
metadata:
  name: item                    # RS 命名为 item
spec:
  replicas: 2                    # pod 副本数量
  selector:
    matchLabels:                 # 使用 label 选择器
      app: item                 # 选取标签是 "app=item" 的pod
  template:
    metadata:
      labels:
        app: item               # 为创建的pod添加标签 "app=item"
    spec:
      containers:
      - name: item             # 容器名
        image: sp-item:v1       # 镜像
EOF

user-service

cat <<EOF > user-rs.yml
apiVersion: apps/v1              # RS 是 apps/v1中提供的资源类型
kind: ReplicaSet                 # 资源类型
metadata:
  name: user                    # RS 命名为 user
spec:
  replicas: 2                    # pod 副本数量
  selector:
    matchLabels:                 # 使用 label 选择器
      app: user                 # 选取标签是 "app=user" 的pod
  template:
    metadata:
      labels:
        app: user               # 为创建的pod添加标签 "app=user"
    spec:
      containers:
      - name: user             # 容器名
        image: sp-user:v1       # 镜像
EOF

order-service

cat <<EOF > order-rs.yml
apiVersion: apps/v1              # RS 是 apps/v1中提供的资源类型
kind: ReplicaSet                 # 资源类型
metadata:
  name: order                    # RS 命名为 order
spec:
  replicas: 2                    # pod 副本数量
  selector:
    matchLabels:                 # 使用 label 选择器
      app: order                 # 选取标签是 "app=order" 的pod
  template:
    metadata:
      labels:
        app: order               # 为创建的pod添加标签 "app=order"
    spec:
      containers:
      - name: order             # 容器名
        image: sp-order:v1       # 镜像
EOF

对外暴露order服务,进行测试

cat <<EOF > order-svc.yml
apiVersion: v1
kind: Service
metadata:
  name: order
spec:
  type: NodePort           # 在每个节点上开放访问端口
  ports:
  - port: 8201              # 集群内部访问该服务的端口
    targetPort: 8201       # 容器的端口
    nodePort: 30201        # 外部访问端口
  selector:
    app: order
EOF

 k8s部署Spring Cloud应用_扎瓦江石的博客-CSDN博客_k8s部署springcloud